Imagina un asistente de investigación con IA capaz de:
- Buscar en la web fuentes relevantes
- Extraer y verificar información de múltiples sitios web
- Cruzar datos para garantizar la precisión
- Sintetizar los hallazgos en un resumen coherente con citas
Con Claude, el Model Context Protocol (MCP) y CrawlForge, puedes construir esto en una tarde. Esta guía te lleva por la arquitectura, la implementación y las consideraciones de producción.
La visión: investigar como un humano
Los LLM tradicionales están limitados a sus datos de entrenamiento. Cuando le haces una pregunta a GPT-4 o a Claude, solo pueden recordar lo que han visto antes. Pero los humanos no funcionamos así: buscamos, leemos, verificamos y sintetizamos información nueva.
Un asistente de investigación con IA debería:
- Entender la intención - Descomponer consultas complejas en temas buscables
- Descubrir fuentes - Encontrar páginas web, documentación y artículos relevantes
- Extraer información - Sacar datos, citas y cifras clave
- Verificar la precisión - Contrastar la información entre varias fuentes
- Sintetizar resultados - Combinar los hallazgos en una respuesta clara y con citas
Vamos a construirlo.
Resumen de la arquitectura
Nuestro asistente de investigación tiene tres capas:
┌─────────────────────────────────────────────────┐
│ LLM Layer (Claude/GPT-4) │
│ - Query understanding │
│ - Source relevance scoring │
│ - Information synthesis │
└─────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ MCP Server (CrawlForge) │
│ - search_web (5 credits) │
│ - extract_content (2 credits) │
│ - deep_research (10 credits) │
└─────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────┐
│ Web Data Layer │
│ - Google Search results │
│ - Website content │
│ - Structured data │
└─────────────────────────────────────────────────┘
Flujo de datos:
- El usuario envía una consulta de investigación
- El LLM expande la consulta en términos de búsqueda
- CrawlForge busca en la web y extrae el contenido
- El LLM verifica y sintetiza la información
- Devuelve una respuesta estructurada con citas
Configurar el proyecto
Usaremos TypeScript, la API de Claude (u OpenAI) y el MCP server de CrawlForge.
Requisitos previos
Bash
node -v # 18+ required
npm -v # 9+ requiredInicializa el proyecto
Bash
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 --initConfiguración del entorno
Crea .env:
Bash
# Claude API (or use OPENAI_API_KEY)
ANTHROPIC_API_KEY=sk-ant-xxxxx
# CrawlForge API
CRAWLFORGE_API_KEY=cf_live_xxxxxConsigue tu API key de CrawlForge en crawlforge.
Implementar el flujo de investigación
1. Comprensión de la consulta
Primero, necesitamos expandir las consultas del usuario en términos de búsqueda efectivos.
Typescript
// 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
};
}2. Búsqueda web y extracción de contenido
A continuación, buscamos fuentes relevantes y extraemos su contenido.
Typescript
// 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;
}Coste en credits:
- 3 términos de búsqueda × 5 credits = 15 credits
- 15 fuentes × 2 credits = 30 credits
- Total: 45 credits por consulta de investigación
3. Verificación de la información
Cruza los datos entre fuentes para verificar su precisión.
Typescript
// 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
}));
}¿Qué viene ahora?
Ahora que has construido un asistente de investigación básico, puedes:
- Añadir streaming - Transmitir los resultados a medida que se encuentran para mejorar la UX
- Almacenar resultados - Guardar la investigación en una base de datos para recuperarla más tarde
- Construir una interfaz - Crear una interfaz web con Next.js o React
- Añadir webhooks - Recibir notificaciones cuando la investigación finalice
- Afinar los prompts - Optimizarlos para tu caso de uso específico
Recursos
Empieza a construir: consigue 1.000 credits gratis en crawlforge.
