KI & AI
LLM API Integration für Entwickler – Praktischer Guide
Nico FreitagKI & AI
Du willst KI nicht nur nebenbei nutzen – du willst sie in deine App einbauen? Das ist möglich und gar nicht so kompliziert. In diesem Guide zeigen wir, wie du eine LLM-API (OpenAI, Anthropic, etc.) in deine Anwendung integrierst.
Welche API? OpenAI vs. Anthropic
OpenAI API (ChatGPT):
- Sehr verbreitet
- Gutes Sprachmodell
- Günstig
- Aber: Daten-Sicherheit ist ein Thema (US-basiert)
Anthropic API (Claude):
- Sehr gutes Modell
- Beste Sicherheit und Datenschutz
- Etwas teurer
- Großes Kontext-Fenster
Andere: Google Gemini API, Open-Source Modelle (Llama, Mistral auf eigenem Server), etc.
Für die Meisten: OpenAI oder Anthropic. Für sensitive Daten: Anthropic oder selbstgehostete Modelle.
Grundkonzepte
Eine LLM-API funktioniert so:
```
Du → API-Request mit Text → OpenAI-Server → Processing → Response mit generiertem Text → deine App
```
Das ist HTTP-REST-API. Du sendest einen Request mit deinem API-Key, OpenAI (oder Anthropic) verarbeitet den Request und gibt eine Response zurück.
Setup: API-Key besorgen
1. Gehe zu openai.com oder anthropic.com
2. Erstelle einen Account
3. Gehe zu API-Settings
4. Generiere einen API-Key
5. Speichere den Key sicher (z.B. in einer .env Datei, NICHT im Code)
Einfaches Beispiel in Python
```python
import openai
openai.api_key = "dein_api_key"
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "system", "content": "Du bist ein hilfreicher Assistant."},
{"role": "user", "content": "Schreib einen Produktbeschreibung für einen Laptop."}
],
temperature=0.7
)
print(response.choices[0].message.content)
```
Das ist es. Du bekommst einen generierten Text zurück.
Einfaches Beispiel in JavaScript
```javascript
const axios = require('axios');
const response = await axios.post('https://api.openai.com/v1/chat/completions', {
model: 'gpt-4',
messages: [
{ role: 'system', content: 'Du bist ein hilfreicher Assistant.' },
{ role: 'user', content: 'Schreib eine Produktbeschreibung für einen Laptop.' }
]
}, {
headers: {
'Authorization': `Bearer ${process.env.OPENAI_API_KEY}`
}
});
console.log(response.data.choices[0].message.content);
```
Ähnlich wie Python.
Wichtige Parameter
model: Welches Modell? gpt-4, gpt-3.5-turbo, claude-3-sonnet, etc.
messages: Array von Nachrichten. Format: [{ role: 'user'/'assistant'/'system', content: 'text' }]
temperature: 0 = deterministisch (immer gleich), 1 = kreativ (anders jedes Mal). Default 1.
max_tokens: Max Länge der Response. Wichtig für Kosten-Kontrolle.
top_p: Alternative zu Temperature. Mit 0.9 bedeutet: Nutze die top 90% der wahrscheinlichen nächsten Wörter.
Error Handling
Immer Error-Handling implementieren:
```python
try:
response = openai.ChatCompletion.create(...)
except openai.error.RateLimitError:
print("Rate limit reached, warte eine Minute")
except openai.error.APIError:
print("API Error")
except Exception as e:
print(f"Fehler: {e}")
```
APIs können Fehler werfen. Plan dafür.
Streaming
Für lange Responses: Nutze Streaming. Das gibt dir Daten Chunk für Chunk, nicht alles auf einmal.
```python
response = openai.ChatCompletion.create(
...,
stream=True
)
for chunk in response:
content = chunk.choices[0].delta.get("content", "")
print(content, end="", flush=True)
```
Das ist besser für User Experience.
Kosten-Kontrolle
LLM APIs kosten Geld pro Token (etwa 1 Token = 4 Zeichen).
Gpt-4: ~0,03 USD pro 1000 Input-Tokens, 0,06 für Output.
GPT-3.5: ~0,0005 für Input, 0,0015 für Output.
Claude: ~0,003 für Input, 0,015 für Output.
Das addiert sich. Immer max_tokens setzen und Kosten tracken.
```python
# Track costs
tokens_used = response.usage.total_tokens
cost = tokens_used * 0.00003 # Beispiel für GPT-3.5
print(f"Diese Request kostete ${cost}")
```
Rate Limiting
APIs haben Rate-Limits. Wenn du zu viele Requests sendest, blockiert die API dich.
Lösung:
1. Nutze Exponential Backoff (warte länger, wenn Fehler)
2. Batch Requests wenn möglich
3. Upgrade auf höhere Rate Limits (kostet extra)
Production-Checklist
Bevor du deine KI-Integration in Production nimmst:
- [ ] API-Key sicher gelagert (nicht im Code)
- [ ] Error Handling implementiert
- [ ] Rate Limiting gehandhabt
- [ ] Costs tracked und limited
- [ ] Logging implementiert
- [ ] Monitoring für API-Issues
- [ ] User-Feedback-Loop eingebaut
- [ ] Security Review durchgeführt
Fazit
LLM-Integration ist nicht kompliziert. Mit 50 Zeilen Code kannst du eine funktionsfähige Integration bauen. Der Trick ist, richtig zu plan und Fehlerbehandlung richtig zu machen.
Häufige Fragen
Weitere Artikel
KI & AI
Was ist Künstliche Intelligenz? Ein praktischer Leitfaden für Unternehmen
Künstliche Intelligenz (KI) ist eines der Buzz-Worte unserer Zeit. Jedes Unternehmen redet davon, jeder möchte sie nutze...
KI & AIVibe Coding: KI schreibt Code – Chancen und Risiken
"Vibe Coding" – das ist der neue Begriff für Programmieren mit KI-Unterstützung. Du beschreibst, was du brauchst, und Gi...
KI & AIPrompt Engineering Guide – Bessere Antworten von KI-Tools
Die meisten Leute nutzen KI falsch. Sie stellen eine einfache Frage und beschweren sich, dass die Antwort nicht gut ist....