OpenRouter, MCP e LangChain: Guia Completo de Integracao com Perguntas de Entrevista (2026)

O OpenRouter tornou-se o gateway de API preferido para acessar diversos provedores de LLM através de uma interface unificada. Seja para construir aplicacoes de IA, integrar com ferramentas de desenvolvimento ou se preparar para entrevistas tecnicas, entender o OpenRouter e cada vez mais valioso. Este guia cobre desde o uso basico ate integracoes avancadas com MCP e LangChain.

O que e o OpenRouter?

O OpenRouter e uma API unificada que fornece acesso a centenas de modelos de IA de provedores como OpenAI, Anthropic, Google, Meta, Mistral e alternativas de codigo aberto. Em vez de gerenciar chaves de API e SDKs separados para cada provedor, voce usa um unico endpoint e uma unica chave de API.

Principais beneficios:

• API Unica: Um endpoint (https://openrouter.ai/api/v1) para todos os modelos
• Compativel com OpenAI: Substituicao direta para o SDK da OpenAI
• Flexibilidade de modelos: Alterne entre GPT-4, Claude, Llama, Gemini sem alterar o codigo
• Otimizacao de custos: Compare precos entre provedores, use modelos mais baratos para tarefas simples
• Roteamento de fallback: Failover automatico quando um provedor esta fora do ar

Primeiros Passos com o OpenRouter

Configuracao Basica

Cadastre-se em openrouter.ai e obtenha sua chave de API. A API e compativel com OpenAI, entao voce pode usar bibliotecas cliente existentes da 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);

Selecao de Modelos

Os modelos sao especificados usando o formato provedor/nome-do-modelo. Opcoes populares incluem:

Modelo	Melhor Para	Custo (por 1M tokens)
anthropic/claude-3.5-sonnet	Raciocinio complexo, programacao	$3 entrada / $15 saida
openai/gpt-4-turbo	Uso geral, visao	$10 entrada / $30 saida
google/gemini-pro-1.5	Contexto longo (1M tokens)	$1.25 entrada / $5 saida
meta-llama/llama-3.1-70b-instruct	Uso geral economico	$0.50 entrada / $0.75 saida
mistral/mistral-large	Multilingue, hospedagem europeia	$2 entrada / $6 saida

Respostas em 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 o OpenRouter com MCP (Model Context Protocol)

O MCP e o protocolo aberto da Anthropic para conectar assistentes de IA a fontes de dados e ferramentas externas. O OpenRouter pode servir como backend de LLM para aplicacoes habilitadas para MCP.

Visao Geral da Arquitetura MCP

O MCP usa uma arquitetura cliente-servidor:

• MCP Host: A aplicacao de IA (como Claude Desktop ou uma aplicacao personalizada)
• MCP Client: Conecta-se a servidores MCP e gerencia chamadas de ferramentas
• MCP Server: Expoe recursos e ferramentas (bancos de dados, APIs, sistemas de arquivos)

Construindo um Cliente MCP com 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: Leitura/escrita de arquivos locais
• @modelcontextprotocol/server-postgres: Consulta a bancos de dados PostgreSQL
• @modelcontextprotocol/server-github: Acesso a repositorios GitHub
• @modelcontextprotocol/server-slack: Integracao com workspace Slack

Integrando o OpenRouter com LangChain

O LangChain e o framework mais popular para construir aplicacoes LLM. O OpenRouter integra-se perfeitamente, pois e compativel com OpenAI.

Configuracao Basica do 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);

Construindo um 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 LangChain com 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);

Perguntas de Entrevista: OpenRouter e APIs de LLM

1. O que e o OpenRouter e por que voce usaria?

Resposta: O OpenRouter e um gateway de API unificado que fornece acesso a multiplos provedores de LLM (OpenAI, Anthropic, Google, Meta, etc.) atraves de um unico endpoint. Voce usaria para flexibilidade de modelos, otimizacao de custos, failover automatico e gerenciamento simplificado de API, em vez de manter integracoes separadas para cada provedor.

2. Como voce lida com limites de taxa e erros com o OpenRouter?

Resposta: Implemente backoff exponencial para limites de taxa (erros 429). O OpenRouter retorna codigos de status HTTP padrao. Para producao, use os headers x-ratelimit-* para rastrear requisicoes restantes. Habilite roteamento de fallback especificando multiplos modelos - o OpenRouter tenta automaticamente alternativas se o principal falhar.

// 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. Explique a diferenca entre MCP e chamada de funcoes

Resposta: Chamada de funcoes e um mecanismo de requisicao unica onde o LLM retorna JSON estruturado para invocar funcoes predefinidas. MCP e um protocolo persistente que mantem conexoes com servidores externos, suporta comunicacao bidirecional, assinaturas de recursos e interacoes complexas de ferramentas em multiplas etapas. Servidores MCP podem enviar atualizacoes, enquanto chamada de funcoes e puramente requisicao-resposta.

4. Como voce implementaria cache para respostas de LLM?

Resposta: Crie um hash da requisicao (modelo + mensagens + parametros) para criar uma chave de cache. Armazene respostas no Redis ou similar. Considere cache semantico para consultas similares usando embeddings. O OpenRouter suporta cache de prompt para modelos Claude - prefixos repetidos sao armazenados em cache e cobrados com taxas reduzidas.

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. Quais sao os tradeoffs entre diferentes provedores de LLM?

Resposta:

• Claude: Melhor para raciocinio complexo, programacao e documentos longos. Custo mais alto, mas excelente qualidade.
• GPT-4: Forte desempenho geral, melhores capacidades de visao, amplo ecossistema de ferramentas.
• Gemini: Maior janela de contexto (1M+ tokens), economico para documentos grandes.
• Llama/Codigo aberto: Menor custo, pode ser hospedado localmente para privacidade, mas geralmente qualidade inferior aos modelos de fronteira.

6. Como voce lida com dados sensiveis em APIs de LLM?

Resposta: Evite enviar PII quando possivel. Use mascaramento/tokenizacao de dados antes de enviar para APIs. Verifique as politicas de retencao de dados dos provedores. Para requisitos rigorosos, hospede modelos de codigo aberto localmente. O OpenRouter nao armazena prompts por padrao, mas verifique os requisitos de conformidade com provedores especificos.

Melhores Praticas

Otimizacao de Custos

• Use modelos mais baratos (Llama, Mistral) para tarefas simples como classificacao
• Reserve modelos caros (Claude, GPT-4) para raciocinio complexo
• Implemente cache de respostas para consultas repetidas
• Use streaming para fornecer respostas com percepcao mais rapida

Confiabilidade em Producao

• Sempre implemente logica de retry com backoff exponencial
• Configure modelos de fallback para caminhos criticos
• Monitore latencia e taxas de erro por modelo
• Use timeouts para evitar requisicoes travadas

Seguranca

• Nunca exponha chaves de API em codigo do lado do cliente
• Implemente validacao de requisicoes antes de enviar para LLMs
• Defina limites de gastos no painel do OpenRouter
• Registre requisicoes para trilhas de auditoria (excluindo conteudo sensivel)

Conclusao

O OpenRouter simplifica o desenvolvimento de LLM multi-modelo ao fornecer uma API unificada. Combinado com MCP para integracao de ferramentas e LangChain para frameworks de aplicacao, voce pode construir aplicacoes de IA sofisticadas sem dependencia de fornecedor. Entender essas integracoes e cada vez mais importante para entrevistas tecnicas, a medida que a IA se torna central no desenvolvimento de software moderno.