npm install @modelcontextprotocol/sdk

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

// Create the MCP client
const client = new Client({
  name: 'my-app',
  version: '1.0.0',
});

// Connect using Streamable HTTP transport
const transport = new StreamableHTTPClientTransport(
  new URL('https://mcp.batchdata.com'),
  {
    requestInit: {
      headers: {
        Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
      },
    },
  }
);

await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log('Available tools:', tools.map(t => t.name));

// Call a tool
const result = await client.callTool({
  name: 'lookup_property',
  arguments: {
    property_street: '123 Main St',
    property_city: 'Phoenix',
    property_state: 'AZ',
    property_zip: '85001',
  },
});

console.log(result);

// Clean up
await client.close();

# Run directly with npx
npx -y mcp-remote https://mcp.batchdata.com \
   --header "Authorization: Bearer YOUR_API_TOKEN"

{
  "mcpServers": {
    "BatchData": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.batchdata.com",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_API_TOKEN_HERE"
      }
    }
  }
}

npm install ai @ai-sdk/openai @ai-sdk/mcp

import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });

const mcpClient = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://mcp.batchdata.com',
    headers: {
      Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
    },
  },
});

const tools = await mcpClient.tools();

const result = await generateText({
  model: openai('gpt-4o'),
  messages: [
    { role: 'user', content: 'Look up the property at 123 Main St, Phoenix, AZ 85001' }
  ],
  tools,
});

console.log(result.text);

// Clean up
await client.close();

Authorization: Bearer YOUR_API_TOKEN

import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';

const mcpClient = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://mcp.batchdata.com',
    headers: {
      Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
    },
  },
});

const tools = await mcpClient.tools();

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

const client = new Client({
  name: 'my-app',
  version: '1.0.0',
});

const transport = new StreamableHTTPClientTransport(
  new URL('https://mcp.batchdata.com'),
  {
    requestInit: {
      headers: {
        Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
      },
    },
  }
);

await client.connect(transport);

const result = await client.callTool({
  name: 'lookup_property',
  arguments: {
    property_street: '123 Main St',
    property_city: 'San Francisco',
    property_state: 'CA',
    property_zip: '94103',
  },
});

await client.close();

npx -y mcp-remote https://mcp.batchdata.com \
   --header "Authorization: Bearer YOUR_API_TOKEN"

{
  "mcpServers": {
    "batchdata": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.batchdata.com",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_API_TOKEN_HERE"
      }
    }
  }
}

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    url='https://mcp.batchdata.com',
    headers={'Authorization': 'Bearer YOUR_API_TOKEN'}
) as (read_stream, write_stream, _):
    async with ClientSession(read_stream, write_stream) as session:
        await session.initialize()

        result = await session.call_tool(
            'lookup_property',
            arguments={
                'property_street': '123 Main St',
                'property_city': 'San Francisco',
                'property_state': 'CA',
                'property_zip': '94103'
            }
        )

{
  "name": "lookup_property",
  "arguments": {
    "property_street": "123 Main St",
    "property_city": "Phoenix",
    "property_state": "AZ",
    "property_zip": "85001"
  }
}

{
  "phoneNumbers": [
    {
      "number": "5551234567",
      "type": "Mobile",
      "carrier": "AT&T",
      "reachable": true,
      "tcpa": false,  // ⚠️ true = TCPA litigator, DO NOT CALL
      "dnc": false,   // ⚠️ true = Do Not Call registry, DO NOT CALL
      "score": 100
    }
  ]
}

import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });

const mcpClient = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://mcp.batchdata.com',
    headers: {
      Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
    },
  },
});

const tools = await mcpClient.tools();

async function getPropertyDetails(address: string) {
  const result = await generateText({
    model: openai('gpt-4o'),
    messages: [
      { role: 'user', content: `Look up the property at ${address}` }
    ],
    tools,
  });

  return result.text;
}

async function analyzePropertyForInvestment(address: string) {
  const result = await generateText({
    model: openai('gpt-4o'),
    system: `You are a real estate investment analyst. Use the available tools to look up
property data and provide detailed investment analysis.`,
    messages: [
      { role: 'user', content: `Analyze ${address} for investment potential` }
    ],
    tools,
  });

  return result.text;
}

async function comprehensivePropertyResearch(address: string) {
  const result = await generateText({
    model: openai('gpt-4o'),
    system: `You are a real estate research assistant. When analyzing a property:
1. Look up the property details
2. Find comparable properties
3. Skip trace for owner contact information
4. Filter out any contacts with TCPA or DNC flags

Provide a comprehensive analysis.`,
    messages: [
      { role: 'user', content: `Research ${address} thoroughly for investment` }
    ],
    tools,
  });

  return result.text;
}

npm install ai @ai-sdk/openai @ai-sdk/mcp

import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

// 1. Create the LLM provider
const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// 2. Create MCP client for BatchData (Streamable HTTP transport)
const mcpClient = await createMCPClient({
  transport: {
    type: 'http',  // Streamable HTTP transport
    url: 'https://mcp.batchdata.com',
    headers: {
      Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
    },
  },
});

// 3. Get tools from BatchData MCP Server
const tools = await mcpClient.tools();

// 4. Use with generateText - tools are automatically available to the LLM
const result = await generateText({
  model: openai('gpt-4o'),
  messages: [
    {
      role: 'user',
      content: 'Look up the property at 123 Main St, Phoenix, AZ 85001 and analyze it for investment potential',
    },
  ],
  tools,
});

console.log(result.text);

// server/ai-service.ts - Runs on your backend server
import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText, LanguageModelUsage } from 'ai';

export interface AIResponse {
  text: string;
  toolCalls?: ToolCall[];
  usage?: LanguageModelUsage;
}

export interface ToolCall {
  name: string;
  args: Record<string, unknown>;
  response?: unknown;
}

// Singleton MCP client
let mcpClient: Awaited<ReturnType<typeof createMCPClient>> | null = null;

async function getMCPClient() {
  if (!mcpClient) {
    mcpClient = await createMCPClient({
      transport: {
        type: 'http',  // Streamable HTTP transport
        url: 'https://mcp.batchdata.com',
        headers: {
          // ✅ Token from server environment variable - never exposed to client
          Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
        },
      },
    });
  }
  return mcpClient;
}

// ✅ API key from server environment variable - never exposed to client
const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

export async function chat(
  messages: Array<{ role: 'user' | 'assistant'; content: string }>,
  options?: {
    systemPrompt?: string;
    temperature?: number;
  }
): Promise<AIResponse> {
  const { systemPrompt, temperature = 0.7 } = options ?? {};

  const client = await getMCPClient();
  const tools = await client.tools();

  const result = await generateText({
    model: openai('gpt-4o-mini'),
    system: systemPrompt,
    messages,
    tools,
    temperature,
  });

  // Extract tool calls from response steps
  const toolCalls: ToolCall[] = [];
  for (const step of result.steps) {
    for (const toolCall of step.toolCalls) {
      toolCalls.push({
        name: toolCall.toolName,
        args: toolCall.args as Record<string, unknown>,
        response: step.toolResults.find(
          (r: any) => r.toolCallId === toolCall.toolCallId
        )?.result,
      });
    }
  }

  return {
    text: result.text,
    toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
    usage: result.usage,
  };
}

export async function analyzeProperty(address: string): Promise<AIResponse> {
  return chat(
    [{ role: 'user', content: `Analyze the property at ${address} for investment potential` }],
    {
      systemPrompt: `You are a real estate investment analyst. Use the available tools to look up property data and provide detailed investment analysis including wholesale, fix-and-flip, and buy-and-hold strategies.`,
    }
  );
}

// server/routes/ai.ts - Express.js route handler
import express from 'express';
import { chat, analyzeProperty } from '../ai-service';

const router = express.Router();

// POST /api/ai/chat
router.post('/chat', async (req, res) => {
  try {
    const { messages, systemPrompt, temperature } = req.body;
    const result = await chat(messages, { systemPrompt, temperature });
    res.json(result);
  } catch (error) {
    console.error('AI chat error:', error);
    res.status(500).json({ error: 'Failed to process request' });
  }
});

// POST /api/ai/analyze-property
router.post('/analyze-property', async (req, res) => {
  try {
    const { address } = req.body;
    const result = await analyzeProperty(address);
    res.json(result);
  } catch (error) {
    console.error('Property analysis error:', error);
    res.status(500).json({ error: 'Failed to analyze property' });
  }
});

export default router;

// app/api/ai/chat/route.ts - Next.js App Router
import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';
import { NextRequest, NextResponse } from 'next/server';

// ✅ Tokens from server environment - never sent to browser
const openai = createOpenAI({
  apiKey: process.env.OPENAI_API_KEY!,
});

let mcpClient: Awaited<ReturnType<typeof createMCPClient>> | null = null;

async function getMCPClient() {
  if (!mcpClient) {
    mcpClient = await createMCPClient({
      transport: {
        type: 'http',  // Streamable HTTP transport
        url: 'https://mcp.batchdata.com',
        headers: {
          Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
        },
      },
    });
  }
  return mcpClient;
}

export async function POST(request: NextRequest) {
  try {
    const { messages, systemPrompt } = await request.json();

    const client = await getMCPClient();
    const tools = await client.tools();

    const result = await generateText({
      model: openai('gpt-4o-mini'),
      system: systemPrompt,
      messages,
      tools,
    });

    return NextResponse.json({
      text: result.text,
      usage: result.usage,
    });
  } catch (error) {
    console.error('AI error:', error);
    return NextResponse.json(
      { error: 'Failed to process request' },
      { status: 500 }
    );
  }
}

// Frontend code - no API tokens here!
async function analyzeProperty(address: string) {
  const response = await fetch('/api/ai/analyze-property', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ address }),
  });

  if (!response.ok) {
    throw new Error('Failed to analyze property');
  }

  return response.json();
}

// Usage
const result = await analyzeProperty('123 Main St, Phoenix, AZ 85001');
console.log(result.text);

// OpenAI
import { createOpenAI } from '@ai-sdk/openai';
const provider = createOpenAI({ apiKey: '...' });
const model = provider('gpt-4o');

// Anthropic
import { createAnthropic } from '@ai-sdk/anthropic';
const provider = createAnthropic({ apiKey: '...' });
const model = provider('claude-sonnet-4-20250514');

// Google
import { createGoogleGenerativeAI } from '@ai-sdk/google';
const provider = createGoogleGenerativeAI({ apiKey: '...' });
const model = provider('gemini-1.5-pro');

// The rest of the code remains unchanged!
const result = await generateText({
  model,  // Works with any provider
  messages,
  tools,  // BatchData MCP tools work with all providers
});

npm install @ai-sdk/angular

Cannot read properties of undefined (reading 'validate')

npm install @ai-sdk/mcp@^0.0.11

const propertyData = await callMCPTool('lookup_property', {...});
const comparables = await callMCPTool('comparable_property', {...});

const prompt = `
Role: You are an experienced real estate investment analyst.

Task: Analyze this property for wholesale investment potential.

Property Data:
${JSON.stringify(propertyData, null, 2)}

Comparable Properties:
${JSON.stringify(comparables, null, 2)}

Analysis Required:
1. Property Condition Assessment
   - Based on year built, last sale date, and building characteristics
   - Estimate repair needs

2. Market Value Analysis
   - Use comparable properties to estimate current market value
   - Calculate average price per square foot
   - Determine ARV (After Repair Value)

3. Investment Metrics
   - Recommended wholesale offer (70% of ARV minus repairs)
   - Assignment fee potential
   - Holding time estimate

4. Risk Factors
   - Liens or encumbrances
   - Market trends (based on sale dates)
   - Property-specific issues

Format your response as JSON with the following structure:
{
  "estimatedMarketValue": number,
  "estimatedRepairs": number,
  "afterRepairValue": number,
  "recommendedOffer": number,
  "assignmentFee": number,
  "riskLevel": "low" | "medium" | "high",
  "analysis": "detailed analysis text"
}
`;

const llmResponse = await callLLM(prompt);
const investmentAnalysis = JSON.parse(llmResponse);

const skipTraceData = await callMCPTool('skip_trace_property', {...});

const prompt = `
Role: You are a real estate marketing expert.

Task: Prioritize these contacts for outreach and suggest communication strategy.

Contact Data:
${JSON.stringify(skipTraceData, null, 2)}

Requirements:
1. Filter contacts based on compliance:
   - Exclude TCPA litigators (tcpa: true)
   - Exclude Do Not Call numbers (dnc: true)
   - Only include reachable numbers

2. Prioritize contacts by:
   - Phone score (higher is better)
   - Phone type (Mobile preferred)
   - Email verification status

3. Suggest outreach sequence:
   - Which contact method to try first
   - Timing recommendations
   - Message templates

Provide your response as JSON:
{
  "prioritizedContacts": [
    {
      "name": string,
      "contactMethod": "phone" | "email",
      "contactValue": string,
      "priority": number,
      "reason": string
    }
  ],
  "outreachStrategy": string
}
`;

const strategy = await callClaude(prompt);

const properties = await Promise.all([
  callMCPTool('lookup_property', address1),
  callMCPTool('lookup_property', address2),
  callMCPTool('lookup_property', address3)
]);

const prompt = `
Role: You are a market analyst specializing in real estate.

Task: Compare these properties and identify the best investment opportunity.

Properties:
${JSON.stringify(properties, null, 2)}

Analysis:
1. Compare key metrics:
   - Price per square foot
   - Equity percentage
   - Days on market (if active listing)
   - Neighborhood characteristics

2. Identify best opportunity based on:
   - Highest equity potential
   - Best price relative to market
   - Lowest risk profile
   - Strongest exit strategy potential

3. Provide ranking with justification

Return JSON:
{
  "rankings": [
    {
      "propertyAddress": string,
      "rank": number,
      "score": number,
      "pros": string[],
      "cons": string[],
      "recommendedStrategy": string
    }
  ],
  "topPick": {
    "address": string,
    "reasoning": string
  }
}
`;

try {
  const result = await generateText({
    model: openai('gpt-4o'),
    messages: [{ role: 'user', content: 'Look up property at...' }],
    tools,
  });
  console.log(result.text);
} catch (error) {
  if (error.message.includes('401')) {
    console.error('Authentication failed - check your API token');
  } else if (error.message.includes('429')) {
    console.error('Rate limited - retry after delay');
  } else {
    console.error('Error:', error.message);
  }
}

import { createOpenAI } from '@ai-sdk/openai';
import { experimental_createMCPClient as createMCPClient } from '@ai-sdk/mcp';
import { generateText } from 'ai';

// Initialize providers
const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Connect to BatchData MCP Server
const mcpClient = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://mcp.batchdata.com',
    headers: {
      Authorization: `Bearer ${process.env.BATCHDATA_API_TOKEN}`,
    },
  },
});

const tools = await mcpClient.tools();

// Property Lookup
const propertyResult = await generateText({
  model: openai('gpt-4o'),
  messages: [
    { role: 'user', content: 'Look up 123 Main St, Phoenix, AZ 85001' }
  ],
  tools,
});

console.log(propertyResult.text);

// Investment Analysis
const analysisResult = await generateText({
  model: openai('gpt-4o'),
  system: `You are a real estate investment analyst. Analyze properties for
wholesale, fix-and-flip, and buy-and-hold strategies.`,
  messages: [
    { role: 'user', content: 'Analyze 123 Main St, Phoenix, AZ 85001 for investment' }
  ],
  tools,
});

console.log(analysisResult.text);

// Skip Trace with Compliance
const skipTraceResult = await generateText({
  model: openai('gpt-4o'),
  system: `You are a real estate marketing specialist. When returning contact info:
- Filter out any contacts with TCPA or DNC flags
- Only include reachable phone numbers
- Prioritize by phone score`,
  messages: [
    { role: 'user', content: 'Skip trace 123 Main St, Phoenix, AZ 85001' }
  ],
  tools,
});

console.log(skipTraceResult.text);

// Clean up
await mcpClient.close();