LLM API für Entwickler: Vollständiger Integrationsleitfaden

Dieser Leitfaden deckt alles ab, was ein Entwickler benötigt, um LLM-APIs in Produktionsanwendungen zu integrieren: Authentifizierung, Streaming, Tool‑Nutzung, Einbettungen, RAG‑Muster und Kostenmanagement. Alle Beispiele verwenden das OpenAI-kompatible Format und funktionieren mit APIMaster.ai.

Einrichtung

from openai import OpenAI

client = OpenAI(
    api_key="IHR_APIMASTER_SCHLÜSSEL",
    base_url="https://apimaster.ai/v1",
)

Grundlegende Muster

1. Einfacher Chat‑Abschluss

def ask(prompt: str, model: str = "claude-sonnet-4-6") -> str:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

2. System‑Prompt + Konversation

class Conversation:
    def __init__(self, system: str, model: str = "claude-sonnet-4-6"):
        self.model = model
        self.messages = [{"role": "system", "content": system}]
    
    def send(self, user_msg: str) -> str:
        self.messages.append({"role": "user", "content": user_msg})
        resp = client.chat.completions.create(
            model=self.model,
            messages=self.messages,
        )
        reply = resp.choices[0].message.content
        self.messages.append({"role": "assistant", "content": reply})
        return reply

bot = Conversation("Du bist ein erfahrener Python-Entwickler.")
print(bot.send("Was ist der GIL?"))
print(bot.send("Wie kann ich ihn umgehen?"))

3. Streaming

def stream(prompt: str, model: str = "gpt-5.4"):
    with client.chat.completions.stream(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    ) as s:
        for text in s.text_stream:
            yield text

for chunk in stream("Erkläre async/await in Python"):
    print(chunk, end="", flush=True)

4. Strukturierte Ausgabe

from pydantic import BaseModel
from typing import List

class ExtractedData(BaseModel):
    entities: List[str]
    sentiment: str
    summary: str

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": f"Extrahiere Daten und gib JSON zurück, das diesem Schema entspricht: {ExtractedData.schema()}"},
        {"role": "user", "content": "Apple meldete Rekordumsätze. CEO Tim Cook bezeichnete sie als außergewöhnlich."},
    ],
    response_format={"type": "json_object"},
)

data = ExtractedData(**json.loads(response.choices[0].message.content))
print(data.entities)    # ["Apple", "Tim Cook"]
print(data.sentiment)   # "positive"

5. Tool‑Nutzung / Funktionsaufruf

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "execute_sql",
            "description": "Führe eine schreibgeschützte SQL-Abfrage aus",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "database": {"type": "string", "enum": ["users", "orders", "products"]},
                },
                "required": ["query", "database"],
            },
        },
    }
]

def handle_tool_call(tool_name: str, args: dict) -> str:
    # Deine Implementierung
    return json.dumps({"result": "Mockdaten"})

def agent_loop(user_msg: str):
    messages = [{"role": "user", "content": user_msg}]
    
    while True:
        resp = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=tools,
        )
        
        if resp.choices[0].finish_reason != "tool_calls":
            return resp.choices[0].message.content
        
        # Tool-Aufrufe verarbeiten
        messages.append(resp.choices[0].message)
        for tc in resp.choices[0].message.tool_calls:
            result = handle_tool_call(tc.function.name, json.loads(tc.function.arguments))
            messages.append({"role": "tool", "tool_call_id": tc.id, "content": result})

6. Einbettungen

def embed(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return [item.embedding for item in response.data]

# Semantische Ähnlichkeit
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

vecs = embed(["Python ist großartig", "Ich liebe Python", "Java ist ausführlich"])
print(cosine_similarity(vecs[0], vecs[1]))  # Hoch: ~0,95
print(cosine_similarity(vecs[0], vecs[2]))  # Niedriger: ~0,70

7. RAG (Retrieval‑Augmented Generation)

from typing import List

def rag_query(user_question: str, knowledge_base: List[str]) -> str:
    # Schritt 1: Frage einbetten
    q_embedding = embed([user_question])[0]
    doc_embeddings = embed(knowledge_base)
    
    # Schritt 2: Relevanteste Dokumente finden
    similarities = [cosine_similarity(q_embedding, d) for d in doc_embeddings]
    top_indices = sorted(range(len(similarities)), key=lambda i: similarities[i], reverse=True)[:3]
    context = "\n\n".join(knowledge_base[i] for i in top_indices)
    
    # Schritt 3: Antwort mit Kontext generieren
    response = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[
            {"role": "system", "content": f"Antworte nur mit diesem Kontext:\n\n{context}"},
            {"role": "user", "content": user_question},
        ],
    )
    return response.choices[0].message.content

8. Async für hohen Durchsatz

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key="IHR_APIMASTER_SCHLÜSSEL",
    base_url="https://apimaster.ai/v1",
)

async def process_batch(prompts: list[str]) -> list[str]:
    tasks = [
        async_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
            max_tokens=100,
        )
        for p in prompts
    ]
    responses = await asyncio.gather(*tasks)
    return [r.choices[0].message.content for r in responses]

# 50 Prompts gleichzeitig verarbeiten
results = asyncio.run(process_batch(my_prompts))

Checkliste für die Produktion

• API-Schlüssel in Umgebungsvariablen, nicht im Quellcode
• Wiederholungslogik mit exponentiellem Backoff für 429/500-Fehler
• max_tokens gesetzt, um Kosten außer Kontrolle zu vermeiden
• Streaming für benutzerseitige Antworten >2 Sekunden
• Anforderungsprotokollierung mit Token‑Anzahl für Kostenverfolgung
• Ratenbegrenzer, um innerhalb der Providerlimits zu bleiben

Das richtige Modell auswählen

Anwendungsfall	Modell	Kostenstufe
Prototyping	deepseek-v4-flash oder gpt-4o-mini	Sehr niedrig
Produktions‑Chatbot	claude-haiku-4-5	Niedrig
Code‑Assistent	deepseek-v4-flash oder claude-sonnet-4-6	Niedrig–Mittel
Komplexe Analyse	claude-sonnet-4-6	Mittel
Forschung/Argumentation	claude-opus-4-8 oder o3	Hoch

Häufig gestellte Fragen

Was ist eine LLM‑API? Eine LLM‑API ist eine HTTP‑Schnittstelle, über die Ihr Code Text‑Prompts senden und KI‑generierte Antworten erhalten kann. Sie senden ein messages‑Array; die API gibt eine Vervollständigung zurück. Die meisten verwenden das OpenAI Chat Completions‑Format.

Wie wähle ich zwischen LLM‑API‑Anbietern? Berücksichtigen Sie Modellfähigkeiten (Benchmarks), Kosten pro Token, Latenz und Zuverlässigkeit. Für die meisten Anwendungsfälle decken DeepSeek V4 Flash (kostengünstiger Code), Claude Sonnet (Schreiben/Analyse) oder GPT-4o (multimodal) die gängigen Pfade ab. APIMaster ermöglicht den Wechsel des Anbieters mit einer Zeile.

Was ist eine OpenAI-kompatible API? Ein Endpunkt, der dasselbe /v1/chat/completions‑Format wie OpenAI implementiert, sodass Sie die Python‑Bibliothek openai oder jedes OpenAI-kompatible Tool mit Nicht‑OpenAI‑Modellen verwenden können.

Wie behandle ich LLM‑API‑Fehler in der Produktion? Fangen Sie RateLimitError (Wiederholung mit Backoff), APIConnectionError (Wiederholung) und InvalidRequestError (Prompt korrigieren). Verwenden Sie Timeouts und Circuit‑Breaker für die Ausfallsicherheit in der Produktion.

Kann ich einen API‑Schlüssel für mehrere LLM‑Anbieter verwenden? Ja – APIMaster bietet einen einzigen Schlüssel und Endpunkt für GPT, Claude, DeepSeek und Gemini. Wechseln Sie Modelle durch Ändern des Parameters model. Es sind keine anbieterspezifischen Schlüssel oder SDKs erforderlich.

LLM‑API‑Zugang erhalten → · Modelle vergleichen →