BrowseAI Dev

Investigación web respaldada por evidencia para agentes de IA. Verificación de afirmaciones BM25+NLI, puntuaciones de confianza, citas, detección de contradicciones. 12 herramientas MCP. Funciona con Claude Desktop, Cursor, Windsurf. SDK de Python (pip install browseaidev), integraciones con LangChain, CrewAI, LlamaIndex. npx browseai-dev

GitHub

Prueba este MCPPatrocinado

Documentación

LastSearch

Infraestructura de investigación para agentes de IA con Inteligencia Fundamentada — búsqueda web en tiempo real, extracción de evidencia, verificación y citas estructuradas. Cada afirmación está respaldada por una URL. Cada respuesta tiene una puntuación de confianza.

Agent → LastSearch → Internet → Verified answers + sources

Sitio web · Playground · Documentación de API · Alternativas · Discord

Nombres de paquetes: npm: lastsearch · PyPI: lastsearch · LangChain: langchain-lastsearch — Anteriormente lastsearch y lastsearch. Los nombres antiguos siguen funcionando y redirigen automáticamente.

Cómo Funciona

search → fetch pages → neural rerank → extract claims → verify → cited answer (streamed)

Cada respuesta pasa por un pipeline de verificación de múltiples pasos. Sin alucinaciones. Cada afirmación está respaldada por una fuente real.

Verificación y Puntuación de Confianza

Las puntuaciones de confianza están basadas en evidencia — no son autoevaluadas por el LLM. Después de que el LLM extrae afirmaciones y fuentes, un motor de verificación posterior a la extracción comprueba cada afirmación contra el texto real de la página fuente:

Descomposición atómica de afirmaciones — Las afirmaciones compuestas se dividen automáticamente en hechos verificables individuales. "Tesla tuvo $96B de ingresos y 1.8M de entregas" se convierte en dos afirmaciones atómicas, cada una verificada de forma independiente.
Recuperación híbrida que combina coincidencia de palabras clave y semántica — Para cada afirmación, la coincidencia de palabras clave encuentra coincidencias léxicas y los embeddings densos encuentran coincidencias semánticas del texto fuente. Los rankings se fusionan para capturar evidencia parafraseada que la coincidencia de palabras clave por sí sola no detecta (por ejemplo, "previene respuestas fabricadas" coincide con "reduce alucinaciones"). Solo en el nivel premium, con respaldo elegante solo de palabras clave.
Reordenamiento semántico de evidencia — Los candidatos principales por afirmación se reordenan mediante un modelo de verificación creado específicamente, entrenado con más de 1.4M de pares afirmación-evidencia que mejora con cada consulta. Selecciona la mejor evidencia de respaldo, aplica penalizaciones por contradicción y aumentos por paráfrasis.
Búsqueda multi-proveedor — Búsqueda paralela en múltiples proveedores para una mayor diversidad de fuentes. Más fuentes independientes = referencias cruzadas más sólidas = mayor confianza.
Puntuación de autoridad de dominio — Más de 10,000 dominios en 5 niveles (institucional .gov/.edu → noticias importantes → periodismo tecnológico → comunidad → baja calidad). Puntuación dinámica que mejora con datos de verificación reales.
Verificación de citas de fuentes — Las citas extraídas por el LLM se verifican contra el texto real de la página mediante estrategias de coincidencia múltiple.
Consenso entre fuentes — Cada afirmación se verifica contra todos los textos de página disponibles. Las afirmaciones respaldadas por 3 o más dominios independientes obtienen "consenso fuerte". Las afirmaciones de una sola fuente se marcan como "débiles".
Detección de contradicciones — Los pares de afirmaciones se analizan en busca de conflictos semánticos mediante superposición de temas y clasificación de contradicciones. Las contradicciones detectadas se muestran en la respuesta y penalizan la confianza.
Consistencia de múltiples pasadas — En el modo exhaustivo, las afirmaciones se verifican de forma cruzada en pasadas de extracción independientes. Las afirmaciones confirmadas por ambas pasadas reciben un aumento; las inconsistentes se penalizan.
Confianza calibrada automáticamente — La fórmula de confianza multifactorial se ajusta automáticamente a partir de comentarios reales de usuarios. La confianza prevista se alinea con la precisión real con el tiempo. Factores: tasa de verificación, autoridad de dominio, número de fuentes, consenso, diversidad de dominios, fundamentación de afirmaciones, actualidad de fuentes y profundidad de citas.
Recuperación de evidencia por afirmación — Las afirmaciones débiles reciben consultas de búsqueda específicas generadas por el LLM y luego se buscan individualmente en todos los proveedores. Cada afirmación obtiene su propio conjunto de evidencia en lugar de compartir el mismo corpus.
Verificación con contra-consultas — Las afirmaciones verificadas se someten a pruebas de estrés con consultas de búsqueda adversariales del tipo "¿qué refutaría esto?". Si se encuentra contra-evidencia, la confianza de la afirmación se penaliza.
Recuperación iterativa con umbral de confianza — El modo exhaustivo utiliza un bucle controlado por confianza: verificar → si quedan afirmaciones débiles → generar consulta específica → buscar → volver a verificar. Realiza hasta 3 iteraciones con terminación anticipada cuando las consultas se repiten o la confianza alcanza el umbral.
Salud de citas en vivo — En los modos exhaustivo y profundo, cada URL citada se sondea en el servidor y se clasifica como live (resuelve ahora), stale (enlace roto — archivado una vez) o dead (sin DNS, sin archivo — probablemente fabricado). Los agentes de investigación profunda alucinan una proporción significativa de URLs de citas; esto convierte "cada cita resuelve" en una garantía comprobable.

Las afirmaciones incluyen campos de verified, verificationScore, consensusCount y consensusLevel. Las fuentes incluyen verified, authority y urlHealth. Los contradictions detectados y un resumen de citationHealth se devuelven en el nivel superior. Los agentes pueden usar estos campos para tomar decisiones de confianza de forma programática.

Respaldo elegante: Cuando las claves premium no están configuradas, el sistema ejecuta verificación solo con palabras clave. La recuperación semántica y el reordenamiento son mejoras premium transparentes — sin degradación, sin errores.

Modos de Profundidad

Tres niveles de profundidad controlan la exhaustividad de la investigación:

Profundidad	Comportamiento	Caso de uso
`fast` (predeterminado)	Búsqueda única → extracción → pasada de verificación	Consultas rápidas, agentes en tiempo real
`thorough`	Bucle iterativo controlado por confianza (hasta 3 pasadas), recuperación de evidencia por afirmación, verificación con contra-consultas, comprobación de consistencia de múltiples pasadas	Investigación importante, verificación de datos
`deep`	Investigación agéntica premium de múltiples pasos: ciclos iterativos de pensar-buscar-extraer-evaluar (hasta 4 pasos en total). El análisis de brechas identifica información faltante y genera consultas de seguimiento. Las afirmaciones/fuentes se fusionan entre pasos con una verificación final. Confianza objetivo: 0.85. Requiere clave de LastSearch + inicio de sesión. Vuelve al modo exhaustivo cuando se agota la cuota.	Preguntas de investigación complejas, análisis exhaustivo

# Thorough mode
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "What is quantum computing?", "depth": "thorough"}'

# Deep mode (uses premium features)
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "Compare CRISPR approaches for sickle cell disease", "depth": "deep"}'

El modo profundo ejecuta ciclos iterativos de pensar-buscar-extraer-evaluar: cada paso realiza un análisis de brechas para identificar lo que falta, genera consultas de seguimiento específicas y fusiona afirmaciones/fuentes entre pasos con una pasada final de verificación. Apunta a un umbral de confianza de 0.85 (DEEP_CONFIDENCE_THRESHOLD) y ejecuta hasta 3 pasos de seguimiento (MAX_FOLLOW_UP_STEPS, 4 en total incluida la pasada inicial). Utiliza reordenamiento semántico, búsqueda multi-proveedor y consistencia de múltiples pasadas. Cada consulta profunda cuesta 3x de cuota (100 consultas profundas/día). Cuando se agota la cuota, el modo profundo vuelve elegantemente al modo exhaustivo. Sin una clave de LastSearch, el modo profundo también vuelve al modo exhaustivo.

Las respuestas del modo profundo incluyen reasoningSteps que muestra el proceso de investigación de múltiples pasos (número de paso, consulta, análisis de brechas, recuento de afirmaciones, confianza por paso).

API de Streaming

Obtén progreso en tiempo real con streaming de respuestas token por token. El endpoint de streaming envía Eventos Enviados por el Servidor (SSE) a medida que se completa cada paso del pipeline. Los pasos del modo profundo se agrupan por pasada de investigación para una visualización limpia del progreso:

curl -N -X POST https://lastsearch.ai/api/browse/answer/stream \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "What is quantum computing?"}'

Eventos: trace (progreso), sources (descubierto temprano), token (texto de respuesta en streaming), result (respuesta final), done.

Reintento con Retroceso Exponencial

Todas las llamadas API externas (proveedores de búsqueda, LLM, obtención de páginas) se reintentan automáticamente ante fallos transitorios (límites de tasa 429, errores de servidor 5xx) con retroceso exponencial y jitter. Los errores de autenticación (401/403) fallan inmediatamente — sin reintentos desperdiciados.

Memoria de Investigación (Sesiones)

Sesiones de investigación persistentes que acumulan conocimiento en múltiples consultas. Las consultas posteriores recuerdan automáticamente afirmaciones verificadas previamente, construyendo una comprensión más profunda con el tiempo.

Las sesiones requieren una clave de API de LastSearch (ls_xxx) para identidad y propiedad. Obtén una clave gratuita en lastsearch.ai/dashboard. Para MCP, configura la variable de entorno LASTSEARCH_API_KEY. Para el SDK de Python, pasa api_key="ls_xxx". Para la API REST, usa Authorization: Bearer ls_xxx.

# Python SDK
session = client.session("quantum-research")
r1 = session.ask("What is quantum entanglement?")       # 13 claims stored
r2 = session.ask("How is entanglement used in computing?")  # 12 claims recalled!
knowledge = session.knowledge()  # Export all accumulated claims

# Share with other agents or humans
share = session.share()  # Returns shareId + URL
# Another agent forks and continues the research
forked = client.fork_session(share.share_id)

# REST API
curl -X POST https://lastsearch.ai/api/session \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"name": "my-research"}'
# Returns session ID, then:
curl -X POST https://lastsearch.ai/api/session/{id}/ask \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "What is quantum entanglement?"}'

# Share a session publicly
curl -X POST https://lastsearch.ai/api/session/{id}/share \
  -H "Authorization: Bearer ls_xxx"

# Fork a shared session (copies all knowledge)
curl -X POST https://lastsearch.ai/api/session/share/{shareId}/fork \
  -H "Authorization: Bearer ls_xxx"

Cada respuesta de sesión incluye recalledClaims y newClaimsStored. Las sesiones se pueden compartir públicamente y ser bifurcadas por otros agentes — lo que permite flujos de trabajo de investigación colaborativos y multi-agente.

Planificación de Consultas

Las consultas complejas se descomponen automáticamente en sub-consultas enfocadas con etiquetas de intención (definición, evidencia, comparación, contraargumento, técnica, histórica). Cada sub-consulta apunta a un aspecto diferente de la pregunta, maximizando la diversidad de fuentes. Las consultas fácticas simples omiten la planificación por completo — sin latencia añadida.

Precisión Auto-Mejorable

Todo el pipeline de verificación mejora automáticamente con el uso:

Autoridad de dominio — La puntuación dinámica ajusta las puntuaciones de confianza de dominios a medida que se acumula evidencia. Las puntuaciones de nivel estático dominan inicialmente, luego las tasas de verificación reales toman el control.
Umbrales de verificación adaptativos — Los umbrales de verificación de afirmaciones se ajustan por tipo de consulta según las tasas de verificación observadas. ¿Demasiado estricto? Se afloja. ¿Demasiado permisivo? Se endurece.
Ajuste del umbral de consenso — Los umbrales de acuerdo entre fuentes se adaptan según el rendimiento del tipo de consulta.
Optimización de pesos de confianza — La fórmula de confianza multifactorial reequilibra los pesos por tipo de consulta cuando los comentarios de usuarios indican imprecisión.
Optimización del recuento de páginas — Los recuentos de obtención de fuentes se ajustan según los resultados de confianza por tipo de consulta.

Bucle de Comentarios

Envía comentarios sobre los resultados para acelerar el aprendizaje. Los agentes y usuarios pueden calificar los resultados como good, bad o wrong — esto alimenta directamente el motor de umbrales adaptativos.

curl -X POST https://lastsearch.ai/api/browse/feedback \
  -H "Content-Type: application/json" \
  -d '{"resultId": "abc123", "rating": "good"}'

client.feedback(result_id="abc123", rating="good")
# Or flag a specific wrong claim:
client.feedback(result_id="abc123", rating="wrong", claim_index=2)

Inicio Rápido

SDK de Python

pip install lastsearch

from lastsearch import LastSearch

client = LastSearch(api_key="ls_xxx")

# Research with citations
result = client.ask("What is quantum computing?")
print(result.answer)
print(f"Confidence: {result.confidence:.0%}")
for source in result.sources:
    print(f"  - {source.title}: {source.url}")

# Thorough mode — auto-retries if confidence < 60%
thorough = client.ask("What is quantum computing?", depth="thorough")

# Deep mode — multi-step reasoning with gap analysis (requires LastSearch key)
deep = client.ask("Compare CRISPR approaches for sickle cell disease", depth="deep")
for step in deep.reasoning_steps or []:
    print(f"  Step {step.step}: {step.query} ({step.confidence:.0%})")

Integración con LangChain: (PyPI)

pip install langchain-lastsearch

from langchain_lastsearch import LastSearchAnswerTool, LastSearchSearchTool

# Use with any LangChain agent
tools = [
    LastSearchAnswerTool(api_key="ls_xxx"),   # Verified search with citations
    LastSearchSearchTool(api_key="ls_xxx"),    # Basic web search
]

# Standalone usage
tool = LastSearchAnswerTool(api_key="ls_xxx")
result = tool.invoke({"query": "What is quantum computing?", "depth": "thorough"})

5 herramientas disponibles: LastSearchSearchTool, LastSearchAnswerTool (verificada), LastSearchExtractTool, LastSearchCompareTool, LastSearchClarityTool (anti-alucinación).

Servidor MCP (Claude Desktop, Cursor, Windsurf)

npx lastsearch setup

O añádelo manualmente a tu configuración de MCP:

{
  "mcpServers": {
    "lastsearch": {
      "command": "npx",
      "args": ["-y", "lastsearch"],
      "env": {
        "LASTSEARCH_API_KEY": "ls_xxx"
      }
    }
  }
}

Obtén una clave de API gratuita en lastsearch.ai/dashboard.

API REST

# Basic query
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "What is quantum computing?"}'

# Thorough mode (auto-retries if confidence < 60%)
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "What is quantum computing?", "depth": "thorough"}'

# Deep mode (multi-step reasoning)
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{"query": "Compare CRISPR approaches", "depth": "deep"}'

Auto-Alojamiento

El servidor MCP y el frontend son de código abierto y se pueden ejecutar localmente. El motor de verificación es un servicio alojado — todas las solicitudes de API son procesadas por la infraestructura en la nube de LastSearch.

git clone https://github.com/lastsearch-hq/lastsearch.git
cd lastsearch
pnpm install
pnpm dev:web    # Run the frontend locally (API calls go to lastsearch.ai)

Claves de API

Todo acceso a la API requiere una clave de API de LastSearch (ls_xxx). Regístrate gratis en lastsearch.ai/dashboard.

Método	Cómo	Verificación	Límites
Clave de API de LastSearch (Gratis)	`Authorization: Bearer ls_xxx`	Premium completo — verificación semántica, multi-proveedor, consistencia de múltiples pasadas	Cuota generosa con respaldo elegante
Clave de API de LastSearch (Pro)	`Authorization: Bearer ls_xxx`	Premium completo — ilimitado, sin respaldo	Ilimitado + cola prioritaria, claves gestionadas, asientos de equipo
Demo (sitio web)	Sin autenticación necesaria	Verificación por palabras clave	1 consulta/hora por IP

El nivel gratuito incluye 100 consultas premium/día (o ~33 consultas profundas/día a 3x de costo cada una). Cuando se alcanza la cuota, las consultas vuelven elegantemente a la verificación por palabras clave (o el modo profundo vuelve al exhaustivo) — sigue funcionando, solo con coincidencia básica. La cuota se restablece cada 24 horas. Pro elimina todos los límites.

Las respuestas de la API incluyen información de cuota cuando se usa una clave de LastSearch:

{
  "success": true,
  "result": { ... },
  "quota": { "used": 12, "limit": 100, "premiumActive": true }
}

Estructura del Proyecto

/apps/mcp              MCP server (stdio transport, npm: lastsearch)
/packages/shared       Shared types, Zod schemas, constants
/packages/python-sdk   Python SDK (PyPI: lastsearch)
/src                   React frontend (Vite, port 8080)
/supabase              Database migrations

El motor de verificación (servidor de API) está en un repositorio privado separado (lastsearch-hq/lastsearch-engine) y se ejecuta como un servicio alojado.

Endpoints de API

Endpoint	Descripción
`POST /browse/search`	Buscar en la web
`POST /browse/open`	Obtener y analizar una página
`POST /browse/extract`	Extraer afirmaciones estructuradas de una página
`POST /browse/answer`	Pipeline completo: buscar + extraer + citar. `depth`: `"fast"`, `"thorough"` o `"deep"`
`POST /browse/answer/stream`	Respuesta en streaming vía SSE — streaming de tokens en tiempo real + eventos de progreso
`POST /browse/compare`	Comparar LLM crudo vs respuesta respaldada por evidencia
`POST /browse/clarity`	Clarity — motor de respuestas anti-alucinación. Tres modos: `mode: "prompt"` (solo prompts mejorados), `mode: "answer"` (respuesta LLM, predeterminado), `mode: "verified"` (LLM + fusión web). Legado `verify: true` = `mode: "verified"`
`GET /browse/share/:id`	Obtener un resultado compartido
`GET /browse/stats`	Total de consultas respondidas
`GET /browse/sources/top`	Dominios de fuentes más citados
`GET /browse/analytics/summary`	Analíticas de uso (autenticado)
`POST /session`	Crear una sesión de investigación
`POST /session/:id/ask`	Investigar con memoria de sesión (recuerda + almacena afirmaciones)
`POST /session/:id/recall`	Consultar el conocimiento de la sesión sin nueva búsqueda
`GET /session/:id/knowledge`	Exportar todas las afirmaciones de la sesión
`POST /session/:id/share`	Compartir una sesión públicamente (devuelve shareId)
`GET /session/share/:shareId`	Ver una sesión compartida (pública, sin autenticación)
`POST /session/share/:shareId/fork`	Bifurcar una sesión compartida en tu cuenta
`GET /session/:id`	Obtener detalles de la sesión
`GET /sessions`	Listar tus sesiones (autenticado)
`DELETE /session/:id`	Eliminar una sesión (autenticado)
`POST /browse/feedback`	Enviar comentarios sobre un resultado (bueno/malo/incorrecto)
`GET /browse/learning/stats`	Estadísticas del motor de autoaprendizaje
`GET /user/stats`	Estadísticas de tus consultas (autenticado)
`GET /user/history`	Historial de tus consultas (autenticado)
`DELETE /user/data`	Eliminar todos tus datos (derecho al olvido GDPR)

Herramientas MCP

Herramienta	Descripción
`search`	Buscar en la web información sobre cualquier tema
`open`	Obtener y analizar una página web en texto limpio
`extract`	Extraer afirmaciones estructuradas de una página
`answer`	Pipeline completo: buscar + extraer + citar. `depth`: `"fast"`, `"thorough"` o `"deep"`
`compare`	Comparar LLM crudo vs respuesta respaldada por evidencia
`clarity`	Motor de respuestas anti-alucinación — tres modos: prompt (solo prompts), answer (LLM), verified (LLM + fusión web)
`session_create`	Crear una sesión de investigación (memoria persistente)
`session_ask`	Investigar dentro de una sesión (recuerda conocimiento previo)
`session_recall`	Consultar el conocimiento de la sesión sin nueva búsqueda web
`session_share`	Compartir una sesión públicamente (devuelve URL de compartir)
`session_knowledge`	Exportar todas las afirmaciones de una sesión
`session_fork`	Bifurcar una sesión compartida para continuar la investigación
`feedback`	Enviar comentarios sobre un resultado para mejorar la precisión

SDK de Python

Método	Descripción
`client.search(query)`	Buscar en la web
`client.open(url)`	Obtener y analizar una página
`client.extract(url, query=)`	Extraer afirmaciones de una página
`client.ask(query, depth=)`	Pipeline completo con citas. `depth`: `"fast"`, `"thorough"` o `"deep"`
`client.compare(query)`	LLM crudo vs respaldado por evidencia
`client.session(name)`	Crear una sesión de investigación
`session.ask(query, depth=)`	Investigar con recuperación de memoria
`session.recall(query)`	Consultar el conocimiento de la sesión
`session.knowledge()`	Exportar todas las afirmaciones de la sesión
`session.share()`	Compartir sesión públicamente (devuelve shareId + URL)
`client.get_session(id)`	Reanudar una sesión existente por ID
`client.list_sessions()`	Listar todas tus sesiones
`client.fork_session(share_id)`	Bifurcar una sesión compartida en tu cuenta
`session.delete()`	Eliminar una sesión
`client.feedback(result_id, rating)`	Enviar comentarios (bueno/malo/incorrecto) para mejorar la precisión

Soporte asíncrono: AsyncLastSearch con la misma API.

Proveedores de búsqueda empresarial

Usa LastSearch con tus propias fuentes de datos en lugar de — o junto con — la búsqueda web pública. Soporta Elasticsearch, Confluence y endpoints personalizados con retención de datos cero opcional para cumplimiento normativo.

# Elasticsearch
result = client.ask("What is our refund policy?", search_provider={
    "type": "elasticsearch",
    "endpoint": "https://es.internal.company.com/kb/_search",
    "authHeader": "Bearer es-token-xxx",
    "index": "docs",
})

# Confluence
result = client.ask("PCI compliance process?", search_provider={
    "type": "confluence",
    "endpoint": "https://company.atlassian.net/wiki/rest/api",
    "authHeader": "Basic base64-creds",
    "spaceKey": "ENG",
})

# Zero data retention (nothing stored, cached, or logged)
result = client.ask("Patient protocols", search_provider={
    "type": "elasticsearch",
    "endpoint": "https://es.hipaa.company.com/medical/_search",
    "authHeader": "Bearer token",
    "dataRetention": "none",
})

# REST API — enterprise search
curl -X POST https://lastsearch.ai/api/browse/answer \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ls_xxx" \
  -d '{
    "query": "What is our refund policy?",
    "searchProvider": {
      "type": "elasticsearch",
      "endpoint": "https://es.internal.company.com/kb/_search",
      "authHeader": "Bearer es-token-xxx",
      "index": "docs"
    }
  }'

Estructura de respuesta

Cada respuesta incluye campos estructurados para decisiones de confianza programáticas:

{
  "answer": "Quantum computing uses qubits...",
  "confidence": 0.82,
  "shareId": "abc123def456",
  "effectiveDepth": "thorough",
  "claims": [
    {
      "claim": "Qubits can exist in superposition",
      "sources": ["https://en.wikipedia.org/wiki/Qubit"],
      "verified": true,
      "verificationScore": 0.87,
      "consensusCount": 3,
      "consensusLevel": "strong"
    }
  ],
  "sources": [
    {
      "url": "https://en.wikipedia.org/wiki/Qubit",
      "title": "Qubit - Wikipedia",
      "domain": "en.wikipedia.org",
      "quote": "A qubit is the basic unit of quantum information...",
      "verified": true,
      "authority": 0.70
    }
  ],
  "contradictions": [
    {
      "claimA": "Quantum computers are faster for all tasks",
      "claimB": "Quantum advantage only applies to specific problems",
      "topic": "quantum computing performance",
      "nliConfidence": 0.89
    }
  ],
  "reasoningSteps": [
    { "step": 1, "query": "quantum computing basics", "gapAnalysis": "Initial research pass", "claimCount": 8, "confidence": 0.65 },
    { "step": 2, "query": "quantum computing vs classical comparison", "gapAnalysis": "Missing classical vs quantum comparison", "claimCount": 14, "confidence": 0.82 }
  ],
  "trace": [
    { "step": "Search Web", "duration_ms": 423, "detail": "5 results" },
    { "step": "Fetch Pages", "duration_ms": 1205, "detail": "4 pages" }
  ],
  "quota": { "used": 12, "limit": 50, "premiumActive": true }
}

Campos clave:

confidence — puntuación basada en evidencia (0-1), no autoevaluada por LLM
shareId — ID único para compartir este resultado (usar con /browse/share/:id)
effectiveDepth — profundidad real utilizada ("fast", "thorough" o "deep") — puede diferir de la profundidad solicitada debido a la degradación
claims[].verified — si la afirmación fue verificada contra el texto fuente
claims[].consensusLevel — "strong" (3+ fuentes), "moderate" o "weak"
contradictions — conflictos detectados entre afirmaciones (con puntuación de confianza)
reasoningSteps — solo modo profundo: iteraciones de investigación multi-paso con análisis de brechas
trace — cronología de ejecución para depuración y monitoreo
quota — uso de cuota premium (solo usuarios de clave LastSearch): used, limit, premiumActive

Ejemplos

Consulta el directorio examples/ para recetas de agentes listas para ejecutar:

Recetas de agentes

Ejemplo	Descripción
research-agent.py	Agente de investigación simple con citas
deep-research-agent.py	Razonamiento profundo multi-paso con análisis de brechas
streaming-agent.py	Streaming SSE en tiempo real con eventos de progreso
contradiction-detector.py	Detectar contradicciones entre fuentes
enterprise-search.py	Fuentes de datos personalizadas + modo de retención cero
code-research-agent.py	Investigar bibliotecas/documentación antes de escribir código
hallucination-detector.py	Comparar LLM crudo vs respuestas respaldadas por evidencia
langchain-agent.py	LastSearch como herramienta LangChain
crewai-research-team.py	Equipo de investigación multi-agente con CrewAI
research-session.py	Sesiones de investigación con memoria persistente

Tutoriales

Tutorial	Lo que construirás
coding-agent/	Agente que investiga antes de escribir código — nunca recomienda bibliotecas obsoletas
support-agent/	Agente que verifica respuestas antes de responder — escala cuando la confianza es baja
content-agent/	Agente que escribe publicaciones de blog donde cada estadística tiene una cita
fact-checker-bot/	Bot de Discord que verifica cualquier afirmación con `!verify` y `!compare`
is-this-true/	Aplicación web — pega cualquier frase, obtén una puntuación de confianza y fuentes
debate-settler/	Herramienta CLI — dos afirmaciones compiten, la evidencia decide al ganador
docs-verifier/	Verifica cada afirmación factual en tu README o documentación
podcast-prep/	Constructor de resúmenes de investigación para entrevistas de podcast

Variables de entorno

Estas son para ejecutar el servidor MCP o el frontend localmente. El motor de verificación se ejecuta como un servicio alojado y no requiere configuración local.

Variable	Requerida	Descripción
`LASTSEARCH_API_KEY`	Sí (MCP)	Clave API de LastSearch (`ls_xxx`) — obtén una en lastsearch.ai/dashboard

Stack tecnológico

API: Node.js, TypeScript, Fastify, Zod
Búsqueda: Multi-proveedor (búsqueda paralela entre fuentes)
Análisis: @mozilla/readability + linkedom
IA: LLM vía OpenRouter
Caché: Redis o en memoria con TTL inteligente (consultas sensibles al tiempo obtienen TTL más corto)
Frontend: React, Tailwind CSS, shadcn/ui, Framer Motion
Verificación: Coincidencia híbrida de palabras clave + semántica con reordenamiento de evidencia
MCP: @modelcontextprotocol/sdk
SDK de Python: httpx, Pydantic
Base de datos: Supabase (PostgreSQL)

Habilidades de agente

Habilidades preconstruidas que enseñan a agentes de codificación de IA (Claude Code, Codex, Cursor, etc.) cuándo y cómo usar LastSearch:

npx skills add lastsearch-hq/lastsearch-skills

Habilidad	Qué hace
research	Respuestas respaldadas por evidencia con citas y confianza
fact-check	Comparar LLM crudo vs respaldado por evidencia, verificar afirmaciones
extract	Extracción estructurada de afirmaciones desde URLs
sessions	Investigación multi-consulta con conocimiento persistente
deep-dive	Investigación agéntica multi-paso con cadenas de razonamiento y análisis de brechas
compare-claims	Resolver disputas factuales — respaldado por evidencia vs LLM crudo lado a lado
monitor	Rastrear temas en evolución a lo largo del tiempo, comparar con conocimiento previo
cite	Generar citas formateadas (APA/MLA) con puntuaciones de autoridad
clarity	Clarity — motor de respuestas anti-alucinación con verificación web opcional

Ver todas las habilidades →

Comunidad

Discord — preguntas, comentarios, exhibición
GitHub Issues — errores, solicitudes de funciones

Contribuciones

Consulta CONTRIBUTING.md para instrucciones de configuración, convenciones de codificación y proceso de PR.

Licencia

Este proyecto utiliza un modelo de núcleo abierto:

Componente	Licencia	Qué significa
SDKs, servidor MCP, integraciones, frontend (este repositorio)	Apache 2.0	Usa libremente, modifica, redistribuye
Motor de verificación (repositorio privado separado)	BSL 1.1	Servicio alojado — gratis de usar vía API, pero el código fuente no es público. Se convierte a Apache 2.0 el 2030-03-25

Consulta el archivo LICENSE para detalles sobre este repositorio.