KI & AI
LLM API Integration für Entwickler – Praktischer Guide
Kevin KrögerKI & 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
Conclusion
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.
About the Author
Kevin Kröger
Founder & Geschäftsführer
Kevin Kröger is the founder and CEO of AXIS/PORT. He oversees SaaS development, cloud infrastructure, and technical project management.