OpenRouter, MCP und LangChain: Vollstandiger Integrationsleitfaden mit Interview-Fragen (2026)

OpenRouter hat sich zum bevorzugten API-Gateway für den Zugriff auf mehrere LLM-Anbieter über eine einzige Schnittstelle entwickelt. Ob Sie KI-Anwendungen entwickeln, Entwicklungstools integrieren oder sich auf technische Vorstellungsgespräche vorbereiten - das Verständnis von OpenRouter wird immer wertvoller. Dieser Leitfaden behandelt alles von der grundlegenden Nutzung bis hin zu fortgeschrittenen Integrationen mit MCP und LangChain.

Was ist OpenRouter?

OpenRouter ist eine einheitliche API, die Zugang zu Hunderten von KI-Modellen von Anbietern wie OpenAI, Anthropic, Google, Meta, Mistral und Open-Source-Alternativen bietet. Anstatt separate API-Schlüssel und SDKs für jeden Anbieter zu verwalten, verwenden Sie einen Endpunkt und einen API-Schlüssel.

Wichtige Vorteile:

• Einzelne API: Ein Endpunkt (https://openrouter.ai/api/v1) für alle Modelle
• OpenAI-kompatibel: Direkter Ersatz für das OpenAI SDK
• Modellflexibilität: Wechseln Sie zwischen GPT-4, Claude, Llama, Gemini ohne Codeänderungen
• Kostenoptimierung: Vergleichen Sie Preise verschiedener Anbieter, verwenden Sie günstigere Modelle für einfache Aufgaben
• Fallback-Routing: Automatisches Failover, wenn ein Anbieter ausfällt

Erste Schritte mit OpenRouter

Grundlegende Einrichtung

Registrieren Sie sich auf openrouter.ai und holen Sie sich Ihren API-Schlüssel. Die API ist OpenAI-kompatibel, sodass Sie vorhandene OpenAI-Client-Bibliotheken verwenden können:

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

Modellauswahl

Modelle werden im Format provider/model-name angegeben. Beliebte Optionen sind:

Modell	Am besten geeignet für	Kosten (pro 1M Token)
anthropic/claude-3.5-sonnet	Komplexe Schlussfolgerungen, Programmierung	$3 Eingabe / $15 Ausgabe
openai/gpt-4-turbo	Allzweck, Vision	$10 Eingabe / $30 Ausgabe
google/gemini-pro-1.5	Langer Kontext (1M Token)	$1,25 Eingabe / $5 Ausgabe
meta-llama/llama-3.1-70b-instruct	Kostengünstige allgemeine Nutzung	$0,50 Eingabe / $0,75 Ausgabe
mistral/mistral-large	Mehrsprachig, europäisches Hosting	$2 Eingabe / $6 Ausgabe

Streaming-Antworten

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 von OpenRouter mit MCP (Model Context Protocol)

MCP ist Anthropics offenes Protokoll zur Verbindung von KI-Assistenten mit externen Datenquellen und Werkzeugen. OpenRouter kann als LLM-Backend für MCP-fähige Anwendungen dienen.

MCP-Architektur im Überblick

MCP verwendet eine Client-Server-Architektur:

• MCP-Host: Die KI-Anwendung (wie Claude Desktop oder eine benutzerdefinierte App)
• MCP-Client: Verbindet sich mit MCP-Servern und verwaltet Werkzeugaufrufe
• MCP-Server: Stellt Ressourcen und Werkzeuge bereit (Datenbanken, APIs, Dateisysteme)

Erstellen eines MCP-Clients mit 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);
  }
}

Beliebte MCP-Server

• @modelcontextprotocol/server-filesystem: Lokale Dateien lesen/schreiben
• @modelcontextprotocol/server-postgres: PostgreSQL-Datenbanken abfragen
• @modelcontextprotocol/server-github: GitHub-Repository-Zugriff
• @modelcontextprotocol/server-slack: Slack-Workspace-Integration

Integration von OpenRouter mit LangChain

LangChain ist das beliebteste Framework für die Entwicklung von LLM-Anwendungen. OpenRouter integriert sich nahtlos, da es OpenAI-kompatibel ist.

Grundlegende LangChain-Einrichtung

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

Aufbau einer RAG-Pipeline

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

LangChain-Agenten mit 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);

Interviewfragen: OpenRouter und LLM-APIs

1. Was ist OpenRouter und warum würde man es verwenden?

Antwort: OpenRouter ist ein einheitliches API-Gateway, das Zugang zu mehreren LLM-Anbietern (OpenAI, Anthropic, Google, Meta usw.) über einen einzigen Endpunkt bietet. Man würde es für Modellflexibilität, Kostenoptimierung, automatisches Failover und vereinfachtes API-Management verwenden, anstatt separate Integrationen für jeden Anbieter zu pflegen.

2. Wie behandelt man Rate Limits und Fehler bei OpenRouter?

Antwort: Implementieren Sie exponentielles Backoff für Rate Limits (429-Fehler). OpenRouter gibt Standard-HTTP-Statuscodes zurück. Für die Produktion verwenden Sie die x-ratelimit-*-Header, um verbleibende Anfragen zu verfolgen. Aktivieren Sie Fallback-Routing, indem Sie mehrere Modelle angeben - OpenRouter versucht automatisch Alternativen, wenn das primäre Modell fehlschlägt.

// 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. Erklären Sie den Unterschied zwischen MCP und Function Calling

Antwort: Function Calling ist ein Einzelanfrage-Mechanismus, bei dem das LLM strukturiertes JSON ausgibt, um vordefinierte Funktionen aufzurufen. MCP ist ein persistentes Protokoll, das Verbindungen zu externen Servern aufrechterhält, bidirektionale Kommunikation, Ressourcen-Abonnements und komplexe mehrstufige Werkzeuginteraktionen unterstützt. MCP-Server können Updates pushen, während Function Calling rein auf Anfrage-Antwort basiert.

4. Wie würde man Caching für LLM-Antworten implementieren?

Antwort: Hashen Sie die Anfrage (Modell + Nachrichten + Parameter), um einen Cache-Schlüssel zu erstellen. Speichern Sie Antworten in Redis oder ähnlichem. Erwägen Sie semantisches Caching für ähnliche Anfragen mittels Embeddings. OpenRouter unterstützt Prompt-Caching für Claude-Modelle - wiederholte Präfixe werden gecacht und zu reduzierten Tarifen abgerechnet.

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. Was sind die Abwägungen zwischen verschiedenen LLM-Anbietern?

Antwort:

• Claude: Am besten für komplexe Schlussfolgerungen, Programmierung und lange Dokumente. Höhere Kosten, aber ausgezeichnete Qualität.
• GPT-4: Starke allgemeine Leistung, beste Vision-Fähigkeiten, breites Werkzeug-Ökosystem.
• Gemini: Längstes Kontextfenster (1M+ Token), kostengünstig für große Dokumente.
• Llama/Open-Source: Niedrigste Kosten, kann selbst gehostet werden für Datenschutz, aber generell niedrigere Qualität als Spitzenmodelle.

6. Wie behandelt man sensible Daten bei LLM-APIs?

Antwort: Vermeiden Sie das Senden von personenbezogenen Daten, wenn möglich. Verwenden Sie Datenmaskierung/Tokenisierung vor dem Senden an APIs. Überprüfen Sie die Datenspeicherungsrichtlinien der Anbieter. Für strenge Anforderungen hosten Sie Open-Source-Modelle selbst. OpenRouter speichert Prompts standardmäßig nicht, aber überprüfen Sie die Compliance-Anforderungen bei spezifischen Anbietern.

Best Practices

Kostenoptimierung

• Verwenden Sie günstigere Modelle (Llama, Mistral) für einfache Aufgaben wie Klassifizierung
• Reservieren Sie teure Modelle (Claude, GPT-4) für komplexe Schlussfolgerungen
• Implementieren Sie Antwort-Caching für wiederholte Anfragen
• Verwenden Sie Streaming für schneller wahrgenommene Antworten

Produktionszuverlässigkeit

• Implementieren Sie immer Wiederholungslogik mit exponentiellem Backoff
• Richten Sie Fallback-Modelle für kritische Pfade ein
• Überwachen Sie Latenz und Fehlerraten pro Modell
• Verwenden Sie Timeouts, um hängende Anfragen zu verhindern

Sicherheit

• Legen Sie niemals API-Schlüssel in clientseitigem Code offen
• Implementieren Sie Anfragevalidierung vor dem Senden an LLMs
• Legen Sie Ausgabenlimits im OpenRouter-Dashboard fest
• Protokollieren Sie Anfragen für Audit-Trails (ohne sensible Inhalte)

Fazit

OpenRouter vereinfacht die Multi-Modell-LLM-Entwicklung durch Bereitstellung einer einheitlichen API. In Kombination mit MCP für Werkzeugintegration und LangChain für Anwendungs-Frameworks können Sie anspruchsvolle KI-Anwendungen ohne Anbieterabhängigkeit erstellen. Das Verständnis dieser Integrationen wird für technische Vorstellungsgespräche immer wichtiger, da KI zentral für die moderne Softwareentwicklung wird.