Cómo crear un asistente de investigación con IA usando Claude y MCP

node -v  # 18+ required
npm -v   # 9+ required

mkdir ai-research-assistant
cd ai-research-assistant
npm init -y
npm install @anthropic-ai/sdk dotenv
npm install --save-dev typescript @types/node tsx
npx tsc --init

# Claude API (or use OPENAI_API_KEY)
ANTHROPIC_API_KEY=sk-ant-xxxxx

# CrawlForge API
CRAWLFORGE_API_KEY=cf_live_xxxxx

// src/research/query-processor.ts
import Anthropic from '@anthropic-ai/sdk';

interface QueryExpansion {
  original: string;
  searchTerms: string[];
  intent: 'factual' | 'comparative' | 'tutorial' | 'news';
  depth: 'shallow' | 'moderate' | 'deep';
}

export async function expandQuery(
  query: string,
  anthropic: Anthropic
): Promise<QueryExpansion> {
  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 500,
    messages: [{
      role: 'user',
      content: `Analyze this research query and return JSON:
Query: "${query}"

Return:
{
  "searchTerms": ["term1", "term2", "term3"],
  "intent": "factual|comparative|tutorial|news",
  "depth": "shallow|moderate|deep"
}

Search terms should be optimized for web search.`
    }]
  });

  const content = response.content[0];
  if (content.type !== 'text') throw new Error('Unexpected response');

  const parsed = JSON.parse(content.text);

  return {
    original: query,
    searchTerms: parsed.searchTerms,
    intent: parsed.intent,
    depth: parsed.depth
  };
}

// src/research/web-scraper.ts
interface Source {
  url: string;
  title: string;
  snippet: string;
  content: string;
  extractedAt: Date;
}

export async function findSources(
  searchTerms: string[],
  apiKey: string
): Promise<Source[]> {
  const sources: Source[] = [];

  for (const term of searchTerms) {
    // Use search_web tool (5 credits per search)
    const searchResponse = await fetch('https://crawlforge.dev/api/v1/tools/search_web', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        query: term,
        limit: 5  // Top 5 results per term
      })
    });

    const searchData = await searchResponse.json();
    const results = searchData.results || [];

    // Extract content from each result (2 credits per URL)
    for (const result of results) {
      const contentResponse = await fetch('https://crawlforge.dev/api/v1/tools/extract_content', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          url: result.url
        })
      });

      const contentData = await contentResponse.json();

      sources.push({
        url: result.url,
        title: result.title,
        snippet: result.snippet,
        content: contentData.content || '',
        extractedAt: new Date()
      });
    }
  }

  return sources;
}

// src/research/verifier.ts
interface VerifiedFact {
  claim: string;
  confidence: 'high' | 'medium' | 'low';
  sources: string[];
  conflicts?: string[];
}

export async function verifyInformation(
  sources: Source[],
  anthropic: Anthropic
): Promise<VerifiedFact[]> {
  const sourceTexts = sources.map((s, i) =>
    `[Source ${i + 1}: ${s.url}]
${s.content.slice(0, 1000)}`
  ).join('

');

  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 2000,
    messages: [{
      role: 'user',
      content: `Extract and verify key facts from these sources. Return JSON:

${sourceTexts}

Return:
{
  "facts": [
    {
      "claim": "factual claim",
      "confidence": "high|medium|low",
      "sources": [1, 2],  // Source indices that support this
      "conflicts": ["conflicting information if any"]
    }
  ]
}`
    }]
  });

  const content = response.content[0];
  if (content.type !== 'text') throw new Error('Unexpected response');

  const parsed = JSON.parse(content.text);

  return parsed.facts.map((fact: any) => ({
    claim: fact.claim,
    confidence: fact.confidence,
    sources: fact.sources.map((i: number) => sources[i - 1]?.url || ''),
    conflicts: fact.conflicts
  }));
}