OpenRouter, MCP et LangChain: Guide Complet d'Integration avec Questions d'Entretien (2026)

OpenRouter est devenu la passerelle API de reference pour acceder a plusieurs fournisseurs de LLM via une interface unique. Que vous developpiez des applications IA, integriez des outils de developpement ou prepariez des entretiens techniques, comprendre OpenRouter devient de plus en plus precieux. Ce guide couvre tout, de l'utilisation de base aux integrations avancees avec MCP et LangChain.

Qu'est-ce qu'OpenRouter ?

OpenRouter est une API unifiee qui donne acces a des centaines de modeles IA provenant de fournisseurs comme OpenAI, Anthropic, Google, Meta, Mistral et des alternatives open-source. Au lieu de gerer des cles API et des SDK separes pour chaque fournisseur, vous utilisez un seul point de terminaison et une seule cle API.

Avantages cles :

• API unique : Un seul point de terminaison (https://openrouter.ai/api/v1) pour tous les modeles
• Compatible OpenAI : Remplacement direct du SDK OpenAI
• Flexibilite des modeles : Basculez entre GPT-4, Claude, Llama, Gemini sans modifier le code
• Optimisation des couts : Comparez les tarifs entre fournisseurs, utilisez des modeles moins chers pour les taches simples
• Routage de secours : Basculement automatique lorsqu'un fournisseur est indisponible

Premiers pas avec OpenRouter

Configuration de base

Inscrivez-vous sur openrouter.ai et obtenez votre cle API. L'API est compatible OpenAI, vous pouvez donc utiliser les bibliotheques client OpenAI existantes :

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);

Selection des modeles

Les modeles sont specifies selon le format fournisseur/nom-du-modele. Les choix populaires incluent :

Modele	Ideal pour	Cout (par 1M de tokens)
anthropic/claude-3.5-sonnet	Raisonnement complexe, programmation	3$ entree / 15$ sortie
openai/gpt-4-turbo	Usage general, vision	10$ entree / 30$ sortie
google/gemini-pro-1.5	Contexte long (1M de tokens)	1,25$ entree / 5$ sortie
meta-llama/llama-3.1-70b-instruct	Usage general economique	0,50$ entree / 0,75$ sortie
mistral/mistral-large	Multilingue, hebergement europeen	2$ entree / 6$ sortie

Reponses 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 || '');
}

Integration d'OpenRouter avec MCP (Model Context Protocol)

MCP est le protocole ouvert d'Anthropic pour connecter les assistants IA a des sources de donnees et outils externes. OpenRouter peut servir de backend LLM pour les applications compatibles MCP.

Apercu de l'architecture MCP

MCP utilise une architecture client-serveur :

• Hote MCP : L'application IA (comme Claude Desktop ou une application personnalisee)
• Client MCP : Se connecte aux serveurs MCP et gere les appels d'outils
• Serveur MCP : Expose les ressources et outils (bases de donnees, API, systemes de fichiers)

Construire un client MCP avec 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);
  }
}

Serveurs MCP populaires

• @modelcontextprotocol/server-filesystem : Lecture/ecriture de fichiers locaux
• @modelcontextprotocol/server-postgres : Requetes sur bases de donnees PostgreSQL
• @modelcontextprotocol/server-github : Acces aux depots GitHub
• @modelcontextprotocol/server-slack : Integration avec l'espace de travail Slack

Integration d'OpenRouter avec LangChain

LangChain est le framework le plus populaire pour construire des applications LLM. OpenRouter s'integre parfaitement puisqu'il est compatible OpenAI.

Configuration de base 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);

Construction d'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);

Agents LangChain avec 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);

Questions d'entretien : OpenRouter et API LLM

1. Qu'est-ce qu'OpenRouter et pourquoi l'utiliser ?

Reponse : OpenRouter est une passerelle API unifiee qui donne acces a plusieurs fournisseurs de LLM (OpenAI, Anthropic, Google, Meta, etc.) via un seul point de terminaison. Vous l'utiliseriez pour la flexibilite des modeles, l'optimisation des couts, le basculement automatique et la gestion simplifiee des API au lieu de maintenir des integrations separees pour chaque fournisseur.

2. Comment gerez-vous les limites de debit et les erreurs avec OpenRouter ?

Reponse : Implementez un backoff exponentiel pour les limites de debit (erreurs 429). OpenRouter renvoie des codes de statut HTTP standards. En production, utilisez les en-tetes x-ratelimit-* pour suivre les requetes restantes. Activez le routage de secours en specifiant plusieurs modeles - OpenRouter essaie automatiquement des alternatives si le principal echoue.

// 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. Expliquez la difference entre MCP et l'appel de fonctions

Reponse : L'appel de fonctions est un mecanisme a requete unique ou le LLM produit du JSON structure pour invoquer des fonctions predefinies. MCP est un protocole persistant qui maintient des connexions vers des serveurs externes, supporte la communication bidirectionnelle, les abonnements aux ressources et les interactions d'outils complexes en plusieurs etapes. Les serveurs MCP peuvent envoyer des mises a jour, alors que l'appel de fonctions est purement requete-reponse.

4. Comment implementeriez-vous la mise en cache des reponses LLM ?

Reponse : Hachez la requete (modele + messages + parametres) pour creer une cle de cache. Stockez les reponses dans Redis ou similaire. Envisagez la mise en cache semantique pour des requetes similaires en utilisant des embeddings. OpenRouter supporte la mise en cache des prompts pour les modeles Claude - les prefixes repetes sont mis en cache et factures a des tarifs reduits.

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. Quels sont les compromis entre les differents fournisseurs de LLM ?

Reponse :

• Claude : Meilleur pour le raisonnement complexe, la programmation et les longs documents. Cout plus eleve mais excellente qualite.
• GPT-4 : Forte performance generale, meilleures capacites de vision, large ecosysteme d'outils.
• Gemini : Fenetre de contexte la plus longue (1M+ de tokens), economique pour les grands documents.
• Llama/Open-source : Cout le plus bas, auto-hebergement possible pour la confidentialite, mais generalement qualite inferieure aux modeles de pointe.

6. Comment gerez-vous les donnees sensibles avec les API LLM ?

Reponse : Evitez d'envoyer des donnees personnelles identifiables quand c'est possible. Utilisez le masquage/tokenisation des donnees avant l'envoi aux API. Verifiez les politiques de retention des donnees des fournisseurs. Pour des exigences strictes, auto-hebergez des modeles open-source. OpenRouter ne stocke pas les prompts par defaut, mais verifiez les exigences de conformite avec les fournisseurs specifiques.

Bonnes pratiques

Optimisation des couts

• Utilisez des modeles moins chers (Llama, Mistral) pour les taches simples comme la classification
• Reservez les modeles couteux (Claude, GPT-4) pour le raisonnement complexe
• Implementez la mise en cache des reponses pour les requetes repetees
• Utilisez le streaming pour des reponses percues plus rapides

Fiabilite en production

• Implementez toujours une logique de nouvelle tentative avec backoff exponentiel
• Configurez des modeles de secours pour les chemins critiques
• Surveillez la latence et les taux d'erreur par modele
• Utilisez des timeouts pour eviter les requetes bloquees

Securite

• N'exposez jamais les cles API dans le code cote client
• Implementez la validation des requetes avant l'envoi aux LLM
• Definissez des limites de depenses dans le tableau de bord OpenRouter
• Journalisez les requetes pour les pistes d'audit (en excluant le contenu sensible)

Conclusion

OpenRouter simplifie le developpement LLM multi-modeles en fournissant une API unifiee. Combine avec MCP pour l'integration d'outils et LangChain pour les frameworks d'application, vous pouvez construire des applications IA sophistiquees sans dependance a un fournisseur. Comprendre ces integrations devient de plus en plus important pour les entretiens techniques alors que l'IA devient centrale dans le developpement logiciel moderne.