Claude Api Integreren In Je Eigen Applicatie

Claude API integreren in je eigen applicatie

Dit artikel beschrijft hoe je de Claude API (Messages API, versie 2023-06-01) integreert in een productieapplicatie — gericht op developers die een robuuste, type-safe integratie willen bouwen.

Vereisten

- Anthropic API key (aan te vragen via console.anthropic.com) - Node.js 18+ of Python 3.9+ - @anthropic-ai/sdk v0.18.0 of hoger (Node) / anthropic v0.8.0+ (Python) - Toegang tot een secrets manager (bv. AWS Secrets Manager, HashiCorp Vault)

Stappen

1. Installeer de SDK

```bash npm install @anthropic-ai/sdk@^0.18.0 ```

Voor Python: ```bash pip install anthropic==0.8.0 ```

2. Initialiseer de client met secrets management

```typescript import Anthropic from '@anthropic-ai/sdk';

// Haal API key altijd uit secrets manager, nooit uit clientcode const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY, maxRetries: 3, }); ```

3. Bouw een gateway-laag voor je API calls

Maak een aparte service die alle Anthropic-requests afhandelt. Dit voorkomt dat API keys in clientcode terechtkomen.

```typescript class ClaudeService { private client: Anthropic; private requestLog: RequestLog[] = [];

constructor() { this.client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY }); }

async sendMessage(params: MessageParams): Promise { const startTime = Date.now(); try { const response = await this.client.messages.create({ model: "claude-3-opus-20240229", max_tokens: 1024, system: params.systemPrompt, messages: params.messages, });

this.logRequest({ success: true, latency: Date.now() - startTime, tokensUsed: response.usage.output_tokens, requestId: response.id, });

return this.parseResponse(response); } catch (error) { this.logRequest({ success: false, error, latency: Date.now() - startTime }); throw error; } } } ```

4. Definieer JSON Schema voor structured outputs

Specificeer exacte output structuur zodat Claude voorspelbare data retourneert.

```typescript const extractionSchema = { type: "object", properties: { entities: { type: "array", items: { type: "object", properties: { name: { type: "string" }, type: { type: "string", enum: ["person", "organization", "location"] }, confidence: { type: "number", minimum: 0, maximum: 1 }, }, required: ["name", "type", "confidence"], }, }, summary: { type: "string", maxLength: 200 }, }, required: ["entities", "summary"], }; ```

5. Verstuur een request met structured output

```typescript const response = await client.messages.create({ model: "claude-3-opus-20240229", max_tokens: 1000, system: "Je bent een data-extractie systeem. Geef alleen JSON terug.", messages: [{ role: "user", content: "Extract entities from: 'Tim Cook bezocht Amsterdam.'" }], response_format: { type: "json_object", schema: extractionSchema }, }); ```

6. Implementeer streamming voor interactieve interfaces

```typescript const stream = await client.messages.stream({ model: "claude-3-opus-20240229", max_tokens: 1024, messages: [{ role: "user", content: "Leg quantum computing uit in 3 zinnen." }], });

for await (const chunk of stream) { if (chunk.type === "content_block_delta") { process.stdout.write(chunk.delta.text); } } ```

7. Definieer tools voor tool calling

```typescript const searchTool = { name: "search_database", description: "Search internal database for customer info", input_schema: { type: "object", properties: { query: { type: "string", description: "Search query" }, max_results: { type: "integer", default: 5 }, }, required: ["query"], }, }; ```

8. Verwerk tool calls met error handling

```typescript async function handleToolCall(toolName: string, input: any) { try { switch (toolName) { case "search_database": const results = await database.search(input.query, input.max_results); return { tool_call_id: input.id, output: JSON.stringify(results) }; default: throw new Error(`Unknown tool: ${toolName}`); } } catch (error) { return { is_error: true, tool_call_id: input.id, output: `Error: ${error.message}` }; } } ```

Verificatie

Voer dit commando uit om te testen of de integratie werkt:

```bash curl -X POST https://api.anthropic.com/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "Content-Type: application/json" \ -d '{ "model": "claude-3-opus-20240229", "max_tokens": 50, "messages": [{"role": "user", "content": "Say hello"}] }' ```

Je ontvangt een `200` response met Claude's antwoord als `content[].text`.

Veelgestelde problemen

1. Rate limiting (429 Too Many Requests) Oplossing: Implement exponential back-off met retry logic. De SDK retried max 3 keer standaard, pas aan via `maxRetries` optie.

2. Token limiet overschreden (400 Bad Request) Oplossing: Verlaag `max_tokens` in je request. Claude 3 Opus heeft een context window van 200K tokens, maar output is standaard begrensd.

3. Structured output is geen geldige JSON Oplossing: Controleer of je `response_format` correct is ingesteld. Claude forceert alleen JSON output als `type: "json_object"` is meegegeven met een valide schema.

Het verschil tussen een werkende integratie en een productieklare schuilt in error handling en logging — zorg dat elke mislukte tool call wordt opgevangen, niet genegeerd.