Building Apps with the Anthropic Claude API: A Developer's Technical Guide

npm install @anthropic-ai/sdk
# Add to .env:
# ANTHROPIC_API_KEY=sk-ant-...

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function ask(question: string): Promise<string> {
  const message = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    messages: [
      { role: 'user', content: question }
    ],
  });

  // message.content is an array of content blocks
  const block = message.content[0];
  if (block.type === 'text') return block.text;
  throw new Error('Unexpected response type');
}

const answer = await ask('What is the time complexity of quicksort?');
console.log(answer);

const message = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 2048,
  system: `You are a senior TypeScript engineer reviewing code for a financial services startup.

RULES:
- Flag any potential security vulnerabilities immediately with SEVERITY: HIGH/MEDIUM/LOW
- Always explain WHY something is a problem, not just what the problem is
- Suggest specific fixes with code examples
- Check for: SQL injection, XSS, insecure deserialization, improper auth
- Output format: structured JSON with keys: issues[], suggestions[], overall_score (1-10)

CONSTRAINTS:
- Do not rewrite the entire file — only identify and fix specific issues
- If no issues are found, say so explicitly and explain what you checked`,

  messages: [
    { role: 'user', content: `Review this code:\n\`\`\`typescript\n${userCode}\n\`\`\`` }
  ],
});

import Anthropic from '@anthropic-ai/sdk';
import type { MessageParam } from '@anthropic-ai/sdk';

const client = new Anthropic();

class ConversationSession {
  private history: MessageParam[] = [];
  private system: string;

  constructor(system: string) {
    this.system = system;
  }

  async chat(userMessage: string): Promise<string> {
    // Add user message to history
    this.history.push({ role: 'user', content: userMessage });

    const response = await client.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 2048,
      system: this.system,
      messages: this.history,
    });

    const block = response.content[0];
    if (block.type !== 'text') throw new Error('Expected text response');

    // Add assistant response to history
    this.history.push({ role: 'assistant', content: block.text });

    return block.text;
  }

  reset() { this.history = []; }
  getHistory() { return [...this.history]; }
}

// Usage
const session = new ConversationSession(
  'You are a helpful coding assistant. Keep responses concise.'
);

console.log(await session.chat('How do I read a file in Node.js?'));
console.log(await session.chat('And how do I write to a file?'));
console.log(await session.chat('Can you show me both in a single function?'));

async function streamResponse(prompt: string): Promise<void> {
  const stream = await client.messages.stream({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    messages: [{ role: 'user', content: prompt }],
  });

  // Stream tokens to stdout as they arrive
  for await (const chunk of stream) {
    if (
      chunk.type === 'content_block_delta' &&
      chunk.delta.type === 'text_delta'
    ) {
      process.stdout.write(chunk.delta.text);
    }
  }

  // Get the final message once streaming is complete
  const finalMessage = await stream.finalMessage();
  console.log('\n\nStop reason:', finalMessage.stop_reason);
  console.log('Input tokens:', finalMessage.usage.input_tokens);
  console.log('Output tokens:', finalMessage.usage.output_tokens);
}

import express from 'express';
import Anthropic from '@anthropic-ai/sdk';

const app = express();
app.use(express.json());
const client = new Anthropic();

app.post('/api/chat', async (req, res) => {
  const { messages, system } = req.body;

  // Set SSE headers
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');

  try {
    const stream = await client.messages.stream({
      model: 'claude-sonnet-4-6',
      max_tokens: 2048,
      system,
      messages,
    });

    for await (const chunk of stream) {
      if (
        chunk.type === 'content_block_delta' &&
        chunk.delta.type === 'text_delta'
      ) {
        res.write(`data: ${JSON.stringify({ text: chunk.delta.text })}\n\n`);
      }
    }

    res.write('data: [DONE]\n\n');
    res.end();

  } catch (error) {
    res.write(`data: ${JSON.stringify({ error: 'Stream failed' })}\n\n`);
    res.end();
  }
});

import Anthropic from '@anthropic-ai/sdk';
import type { Tool, MessageParam } from '@anthropic-ai/sdk';

const client = new Anthropic();

// Define your tools
const tools: Tool[] = [
  {
    name: 'get_weather',
    description: 'Get current weather for a city. Returns temperature, condition, and humidity.',
    input_schema: {
      type: 'object',
      properties: {
        city: { type: 'string', description: 'City name, e.g. "London" or "New York"' },
        units: {
          type: 'string',
          enum: ['celsius', 'fahrenheit'],
          description: 'Temperature units. Defaults to celsius.'
        }
      },
      required: ['city']
    }
  },
  {
    name: 'search_database',
    description: 'Search the product database. Returns matching products with price and stock.',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Search query' },
        limit: { type: 'number', description: 'Max results (default 5, max 20)' }
      },
      required: ['query']
    }
  }
];

// Mock tool executors — replace with real implementations
async function executeTool(name: string, input: Record<string, unknown>): Promise<string> {
  if (name === 'get_weather') {
    const { city, units = 'celsius' } = input as { city: string; units?: string };
    // In production: call a real weather API here
    return JSON.stringify({
      city,
      temperature: units === 'celsius' ? 22 : 72,
      condition: 'Partly cloudy',
      humidity: '65%',
      units
    });
  }

  if (name === 'search_database') {
    const { query, limit = 5 } = input as { query: string; limit?: number };
    // In production: query your real database
    return JSON.stringify({
      results: [
        { id: 1, name: `${query} Pro`, price: 99.99, stock: 42 },
        { id: 2, name: `${query} Lite`, price: 49.99, stock: 8 }
      ].slice(0, limit)
    });
  }

  return JSON.stringify({ error: `Unknown tool: ${name}` });
}

// Agentic loop — handles multiple tool calls automatically
async function runAgent(userMessage: string): Promise<string> {
  const messages: MessageParam[] = [
    { role: 'user', content: userMessage }
  ];

  while (true) {
    const response = await client.messages.create({
      model: 'claude-sonnet-4-6',
      max_tokens: 4096,
      tools,
      messages,
    });

    // If Claude is done, return the final text response
    if (response.stop_reason === 'end_turn') {
      const textBlock = response.content.find(b => b.type === 'text');
      return textBlock?.type === 'text' ? textBlock.text : '';
    }

    // Handle tool calls
    if (response.stop_reason === 'tool_use') {
      // Add Claude's response (with tool_use blocks) to history
      messages.push({ role: 'assistant', content: response.content });

      // Execute all tool calls and collect results
      const toolResults = await Promise.all(
        response.content
          .filter(block => block.type === 'tool_use')
          .map(async block => {
            if (block.type !== 'tool_use') return null;
            const result = await executeTool(
              block.name,
              block.input as Record<string, unknown>
            );
            return {
              type: 'tool_result' as const,
              tool_use_id: block.id,
              content: result
            };
          })
      );

      // Add tool results to history and continue the loop
      messages.push({
        role: 'user',
        content: toolResults.filter(Boolean) as Anthropic.ToolResultBlockParam[]
      });
    }
  }
}

// Test it
const result = await runAgent(
  'What\'s the weather in Tokyo right now? Also find me some "wireless headphones" in the store.'
);
console.log(result);

import { z } from 'zod';

// Define the expected schema
const ProductSchema = z.object({
  name: z.string(),
  category: z.string(),
  price_range: z.object({
    min: z.number(),
    max: z.number(),
    currency: z.string()
  }),
  features: z.array(z.string()),
  sentiment: z.enum(['positive', 'neutral', 'negative']),
  confidence: z.number().min(0).max(1)
});

type Product = z.infer<typeof ProductSchema>;

async function extractProductData(rawText: string): Promise<Product> {
  const response = await client.messages.create({
    model: 'claude-sonnet-4-6',
    max_tokens: 1024,
    system: `You are a data extraction API. Always respond with valid JSON only.
No markdown, no explanation, no code fences — just the raw JSON object.
Schema: ${JSON.stringify(ProductSchema.shape, null, 2)}`,
    messages: [
      { role: 'user', content: `Extract product data from this text:\n\n${rawText}` }
    ]
  });

  const block = response.content[0];
  if (block.type !== 'text') throw new Error('Expected text');

  const parsed = JSON.parse(block.text);
  return ProductSchema.parse(parsed); // Zod validates AND types the output
}

// Using a "fake" tool as a structured output mechanism
// Claude MUST call the tool, so output is always structured

const response = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  tool_choice: { type: 'tool', name: 'save_product' }, // Force this tool
  tools: [{
    name: 'save_product',
    description: 'Save the extracted product information',
    input_schema: {
      type: 'object',
      properties: {
        name: { type: 'string' },
        price: { type: 'number' },
        in_stock: { type: 'boolean' },
        tags: { type: 'array', items: { type: 'string' } }
      },
      required: ['name', 'price', 'in_stock', 'tags']
    }
  }],
  messages: [
    { role: 'user', content: `Extract: ${rawText}` }
  ]
});

// The tool call input IS your structured data
const toolUse = response.content.find(b => b.type === 'tool_use');
if (toolUse?.type === 'tool_use') {
  const data = toolUse.input; // Guaranteed to match your schema
  console.log(data);
}

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

const client = new Anthropic();

async function robustCall(
  messages: Anthropic.MessageParam[],
  retries = 3
): Promise<string> {
  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const response = await client.messages.create({
        model: 'claude-sonnet-4-6',
        max_tokens: 1024,
        messages,
      });

      const block = response.content[0];
      if (block.type === 'text') return block.text;
      throw new Error('No text in response');

    } catch (error) {
      if (error instanceof Anthropic.RateLimitError) {
        // 429 — wait before retry
        const waitMs = Math.pow(2, attempt) * 1000; // Exponential backoff
        console.warn(`Rate limited. Waiting ${waitMs}ms before retry ${attempt}/${retries}`);
        await new Promise(r => setTimeout(r, waitMs));
        continue;
      }

      if (error instanceof Anthropic.APIError) {
        if (error.status === 529) {
          // API overloaded — brief wait
          await new Promise(r => setTimeout(r, 2000 * attempt));
          continue;
        }
        if (error.status >= 500) {
          // Server error — retry
          await new Promise(r => setTimeout(r, 1000 * attempt));
          continue;
        }
        // 4xx errors (except 429) are not retriable — bad request, auth, etc.
        throw error;
      }

      throw error; // Unknown error — rethrow
    }
  }

  throw new Error(`Failed after ${retries} attempts`);
}