OpenRouter, MCP y LangChain: Guia Completa de Integracion con Preguntas de Entrevista (2026)

OpenRouter se ha convertido en la puerta de enlace API preferida para acceder a múltiples proveedores de LLM a través de una única interfaz. Ya sea que estés construyendo aplicaciones de IA, integrándote con herramientas de desarrollo o preparándote para entrevistas técnicas, comprender OpenRouter es cada vez más valioso. Esta guía cubre todo, desde el uso básico hasta integraciones avanzadas con MCP y LangChain.

¿Qué es OpenRouter?

OpenRouter es una API unificada que proporciona acceso a cientos de modelos de IA de proveedores como OpenAI, Anthropic, Google, Meta, Mistral y alternativas de código abierto. En lugar de gestionar claves API y SDKs separados para cada proveedor, utilizas un único endpoint y una única clave API.

Beneficios clave:

• API única: Un endpoint (https://openrouter.ai/api/v1) para todos los modelos
• Compatible con OpenAI: Reemplazo directo para el SDK de OpenAI
• Flexibilidad de modelos: Cambia entre GPT-4, Claude, Llama, Gemini sin cambios en el código
• Optimización de costos: Compara precios entre proveedores, usa modelos más económicos para tareas simples
• Enrutamiento de respaldo: Conmutación automática por error cuando un proveedor está caído

Comenzando con OpenRouter

Configuración Básica

Regístrate en openrouter.ai y obtén tu clave API. La API es compatible con OpenAI, por lo que puedes usar las bibliotecas cliente existentes de OpenAI:

import OpenAI from 'openai';

const openrouter = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: process.env.OPENROUTER_API_KEY,
});

const response = await openrouter.chat.completions.create({
  model: 'anthropic/claude-3.5-sonnet',
  messages: [
    { role: 'user', content: 'Explain quantum computing in simple terms' }
  ],
});

console.log(response.choices[0].message.content);

Selección de Modelos

Los modelos se especifican usando el formato proveedor/nombre-del-modelo. Las opciones populares incluyen:

Modelo	Mejor Para	Costo (por 1M de tokens)
anthropic/claude-3.5-sonnet	Razonamiento complejo, programación	$3 entrada / $15 salida
openai/gpt-4-turbo	Propósito general, visión	$10 entrada / $30 salida
google/gemini-pro-1.5	Contexto largo (1M de tokens)	$1.25 entrada / $5 salida
meta-llama/llama-3.1-70b-instruct	Uso general económico	$0.50 entrada / $0.75 salida
mistral/mistral-large	Multilingüe, alojamiento europeo	$2 entrada / $6 salida

Respuestas en Streaming

const stream = await openrouter.chat.completions.create({
  model: 'anthropic/claude-3.5-sonnet',
  messages: [{ role: 'user', content: 'Write a poem about coding' }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || '');
}

Integrando OpenRouter con MCP (Model Context Protocol)

MCP es el protocolo abierto de Anthropic para conectar asistentes de IA con fuentes de datos externas y herramientas. OpenRouter puede servir como backend de LLM para aplicaciones habilitadas con MCP.

Descripción General de la Arquitectura MCP

MCP utiliza una arquitectura cliente-servidor:

• Host MCP: La aplicación de IA (como Claude Desktop o una aplicación personalizada)
• Cliente MCP: Se conecta a servidores MCP y gestiona las llamadas a herramientas
• Servidor MCP: Expone recursos y herramientas (bases de datos, APIs, sistemas de archivos)

Construyendo un Cliente MCP con OpenRouter

import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
import OpenAI from 'openai';

// Initialize OpenRouter client
const openrouter = new OpenAI({
  baseURL: 'https://openrouter.ai/api/v1',
  apiKey: process.env.OPENROUTER_API_KEY,
});

// Connect to MCP server
const transport = new StdioClientTransport({
  command: 'npx',
  args: ['-y', '@modelcontextprotocol/server-filesystem', '/path/to/directory'],
});

const mcpClient = new Client({ name: 'my-app', version: '1.0.0' }, {});
await mcpClient.connect(transport);

// Get available tools from MCP server
const { tools } = await mcpClient.listTools();

// Convert MCP tools to OpenAI function format
const openaiTools = tools.map(tool => ({
  type: 'function',
  function: {
    name: tool.name,
    description: tool.description,
    parameters: tool.inputSchema,
  },
}));

// Chat with tool use
const response = await openrouter.chat.completions.create({
  model: 'anthropic/claude-3.5-sonnet',
  messages: [{ role: 'user', content: 'List files in the current directory' }],
  tools: openaiTools,
});

// Handle tool calls
if (response.choices[0].message.tool_calls) {
  for (const toolCall of response.choices[0].message.tool_calls) {
    const result = await mcpClient.callTool({
      name: toolCall.function.name,
      arguments: JSON.parse(toolCall.function.arguments),
    });
    console.log('Tool result:', result);
  }
}

Servidores MCP Populares

• @modelcontextprotocol/server-filesystem: Leer/escribir archivos locales
• @modelcontextprotocol/server-postgres: Consultar bases de datos PostgreSQL
• @modelcontextprotocol/server-github: Acceso a repositorios de GitHub
• @modelcontextprotocol/server-slack: Integración con espacios de trabajo de Slack

Integrando OpenRouter con LangChain

LangChain es el framework más popular para construir aplicaciones de LLM. OpenRouter se integra perfectamente ya que es compatible con OpenAI.

Configuración Básica de LangChain

import { ChatOpenAI } from '@langchain/openai';

const model = new ChatOpenAI({
  modelName: 'anthropic/claude-3.5-sonnet',
  openAIApiKey: process.env.OPENROUTER_API_KEY,
  configuration: {
    baseURL: 'https://openrouter.ai/api/v1',
  },
});

const response = await model.invoke('What is the capital of France?');
console.log(response.content);

Construyendo un Pipeline RAG

import { ChatOpenAI } from '@langchain/openai';
import { MemoryVectorStore } from 'langchain/vectorstores/memory';
import { OpenAIEmbeddings } from '@langchain/openai';
import { createRetrievalChain } from 'langchain/chains/retrieval';
import { createStuffDocumentsChain } from 'langchain/chains/combine_documents';
import { ChatPromptTemplate } from '@langchain/core/prompts';

// Use OpenRouter for chat, but you need separate embeddings
// (OpenRouter doesn't support embeddings yet)
const model = new ChatOpenAI({
  modelName: 'anthropic/claude-3.5-sonnet',
  openAIApiKey: process.env.OPENROUTER_API_KEY,
  configuration: { baseURL: 'https://openrouter.ai/api/v1' },
});

const embeddings = new OpenAIEmbeddings({
  openAIApiKey: process.env.OPENAI_API_KEY, // Use OpenAI for embeddings
});

// Create vector store from documents
const vectorStore = await MemoryVectorStore.fromTexts(
  ['Document 1 content...', 'Document 2 content...'],
  [{}, {}],
  embeddings
);

// Create retrieval chain
const prompt = ChatPromptTemplate.fromTemplate(`
Answer based on the following context:
{context}

Question: {input}
`);

const documentChain = await createStuffDocumentsChain({ llm: model, prompt });
const retrievalChain = await createRetrievalChain({
  combineDocsChain: documentChain,
  retriever: vectorStore.asRetriever(),
});

const result = await retrievalChain.invoke({ input: 'What is in document 1?' });
console.log(result.answer);

Agentes de LangChain con OpenRouter

import { ChatOpenAI } from '@langchain/openai';
import { initializeAgentExecutorWithOptions } from 'langchain/agents';
import { Calculator } from 'langchain/tools/calculator';
import { WebBrowser } from 'langchain/tools/webbrowser';

const model = new ChatOpenAI({
  modelName: 'openai/gpt-4-turbo',
  openAIApiKey: process.env.OPENROUTER_API_KEY,
  configuration: { baseURL: 'https://openrouter.ai/api/v1' },
});

const tools = [new Calculator()];

const executor = await initializeAgentExecutorWithOptions(tools, model, {
  agentType: 'openai-functions',
  verbose: true,
});

const result = await executor.invoke({
  input: 'What is 15% of 847?',
});

console.log(result.output);

Preguntas de Entrevista: OpenRouter y APIs de LLM

1. ¿Qué es OpenRouter y por qué lo usarías?

Respuesta: OpenRouter es una puerta de enlace API unificada que proporciona acceso a múltiples proveedores de LLM (OpenAI, Anthropic, Google, Meta, etc.) a través de un único endpoint. Lo usarías por la flexibilidad de modelos, optimización de costos, conmutación automática por error y gestión simplificada de APIs en lugar de mantener integraciones separadas para cada proveedor.

2. ¿Cómo manejas los límites de tasa y errores con OpenRouter?

Respuesta: Implementa retroceso exponencial para límites de tasa (errores 429). OpenRouter devuelve códigos de estado HTTP estándar. Para producción, usa los encabezados x-ratelimit-* para rastrear las solicitudes restantes. Habilita el enrutamiento de respaldo especificando múltiples modelos—OpenRouter intenta automáticamente alternativas si el principal falla.

// Fallback example
const response = await openrouter.chat.completions.create({
  model: 'anthropic/claude-3.5-sonnet',
  route: 'fallback',
  models: [
    'anthropic/claude-3.5-sonnet',
    'openai/gpt-4-turbo',
    'google/gemini-pro-1.5'
  ],
  messages: [...],
});

3. Explica la diferencia entre MCP y llamadas a funciones

Respuesta: Las llamadas a funciones son un mecanismo de solicitud única donde el LLM produce JSON estructurado para invocar funciones predefinidas. MCP es un protocolo persistente que mantiene conexiones con servidores externos, soporta comunicación bidireccional, suscripciones a recursos e interacciones complejas de herramientas en múltiples pasos. Los servidores MCP pueden enviar actualizaciones, mientras que las llamadas a funciones son puramente solicitud-respuesta.

4. ¿Cómo implementarías el almacenamiento en caché para respuestas de LLM?

Respuesta: Genera un hash de la solicitud (modelo + mensajes + parámetros) para crear una clave de caché. Almacena las respuestas en Redis o similar. Considera el almacenamiento en caché semántico para consultas similares usando embeddings. OpenRouter soporta almacenamiento en caché de prompts para modelos Claude—los prefijos repetidos se almacenan en caché y se facturan a tarifas reducidas.

import { createHash } from 'crypto';

function getCacheKey(request) {
  return createHash('sha256')
    .update(JSON.stringify({
      model: request.model,
      messages: request.messages,
      temperature: request.temperature,
    }))
    .digest('hex');
}

5. ¿Cuáles son las compensaciones entre diferentes proveedores de LLM?

Respuesta:

• Claude: Mejor para razonamiento complejo, programación y documentos largos. Mayor costo pero excelente calidad.
• GPT-4: Fuerte rendimiento general, mejores capacidades de visión, amplio ecosistema de herramientas.
• Gemini: Ventana de contexto más larga (1M+ tokens), económico para documentos grandes.
• Llama/Código abierto: Menor costo, se puede auto-alojar para privacidad, pero generalmente menor calidad que los modelos de frontera.

6. ¿Cómo manejas datos sensibles con APIs de LLM?

Respuesta: Evita enviar información de identificación personal cuando sea posible. Usa enmascaramiento/tokenización de datos antes de enviar a las APIs. Verifica las políticas de retención de datos de los proveedores. Para requisitos estrictos, auto-aloja modelos de código abierto. OpenRouter no almacena prompts por defecto, pero verifica los requisitos de cumplimiento con proveedores específicos.

Mejores Prácticas

Optimización de Costos

• Usa modelos más económicos (Llama, Mistral) para tareas simples como clasificación
• Reserva modelos costosos (Claude, GPT-4) para razonamiento complejo
• Implementa almacenamiento en caché de respuestas para consultas repetidas
• Usa streaming para proporcionar respuestas con percepción más rápida

Confiabilidad en Producción

• Siempre implementa lógica de reintentos con retroceso exponencial
• Configura modelos de respaldo para rutas críticas
• Monitorea latencia y tasas de error por modelo
• Usa tiempos de espera para prevenir solicitudes colgadas

Seguridad

• Nunca expongas claves API en código del lado del cliente
• Implementa validación de solicitudes antes de enviar a LLMs
• Establece límites de gasto en el panel de OpenRouter
• Registra solicitudes para pistas de auditoría (excluyendo contenido sensible)

Conclusión

OpenRouter simplifica el desarrollo de LLM multi-modelo al proporcionar una API unificada. Combinado con MCP para integración de herramientas y LangChain para frameworks de aplicaciones, puedes construir aplicaciones de IA sofisticadas sin dependencia de proveedores. Comprender estas integraciones es cada vez más importante para entrevistas técnicas a medida que la IA se vuelve central en el desarrollo de software moderno.