Claude API & Agent SDK
~35 min Avançado Parte 5

Claude API & Agent SDK

Como usar a Claude API diretamente e o Agent SDK para construir suas próprias aplicações com IA — mensagens, streaming, tool use e agentes autônomos.

Além do Claude Code CLI, você pode integrar o Claude diretamente em suas aplicações usando o SDK TypeScript ou Python. Esta abordagem é ideal quando você precisa de controle total sobre o fluxo, construir produtos próprios ou automatizar workflows complexos.

Instalação dos SDKs

Instale o SDK oficial da Anthropic para sua linguagem:

# TypeScript / JavaScript
npm install @anthropic-ai/sdk

# Python
pip install anthropic

Claude API direta — primeira mensagem

Integrando Claude diretamente em suas aplicações TypeScript:

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

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

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Explique recursão" }],
});

console.log(message.content[0].text);

O mesmo em Python:

import anthropic

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explique recursão"}]
)

print(message.content[0].text)

Estrutura da resposta

A resposta da API segue um schema consistente:

Campo Tipo Descrição
id string Identificador único da mensagem
content array Blocos de conteúdo (texto, tool_use)
model string Modelo utilizado na resposta
stop_reason string end_turn, tool_use, max_tokens
usage object input_tokens e output_tokens consumidos

Streaming

Receba respostas em tempo real via streaming — essencial para UIs responsivas:

const stream = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  stream: true,
  messages: [{ role: "user", content: "Explique O(n log n)" }],
});

for await (const chunk of stream) {
  if (chunk.type === "content_block_delta") {
    process.stdout.write(chunk.delta.text);
  }
}
Com streaming, o usuário vê o texto sendo gerado em tempo real, em vez de aguardar a resposta completa. Fundamental para chatbots e interfaces interativas.

Conversa multi-turno

Mantenha histórico de conversa passando o array de mensagens acumuladas:

const messages: Anthropic.MessageParam[] = [];

// Primeiro turno
messages.push({ role: "user", content: "O que é uma closure em JavaScript?" });
const resp1 = await client.messages.create({ model: "claude-sonnet-4-6", max_tokens: 512, messages });
messages.push({ role: "assistant", content: resp1.content });

// Segundo turno — Claude lembra do contexto
messages.push({ role: "user", content: "Dê um exemplo prático com contador" });
const resp2 = await client.messages.create({ model: "claude-sonnet-4-6", max_tokens: 512, messages });
console.log(resp2.content[0].text);

Tool Use (function calling)

Defina ferramentas que o Claude pode chamar durante a conversa para buscar dados ou executar ações:

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  tools: [{
    name: "get_weather",
    description: "Get current weather for a city",
    input_schema: {
      type: "object",
      properties: {
        city: { type: "string", description: "City name" }
      },
      required: ["city"]
    }
  }],
  messages: [{ role: "user", content: "Qual o tempo em São Paulo?" }],
});

// Se Claude decidiu usar a tool:
if (response.stop_reason === "tool_use") {
  const toolUse = response.content.find(b => b.type === "tool_use");
  const weatherData = await fetchWeather(toolUse.input.city);

  // Retorne o resultado da tool de volta ao Claude
  const finalResponse = await client.messages.create({
    model: "claude-sonnet-4-6",
    messages: [
      { role: "user", content: "Qual o tempo em São Paulo?" },
      { role: "assistant", content: response.content },
      { role: "user", content: [{ type: "tool_result", tool_use_id: toolUse.id, content: JSON.stringify(weatherData) }] },
    ],
  });
}

System prompt

Defina o comportamento e personalidade do Claude com o campo system:

const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  system: `Você é um assistente de código especializado em TypeScript e Node.js.
Sempre forneça exemplos práticos e explique o raciocínio por trás das suas sugestões.
Use português brasileiro. Seja direto e objetivo.`,
  messages: [{ role: "user", content: "Como implementar rate limiting em Express?" }],
});

Agent SDK (@anthropic-ai/agent-sdk)

Construa agentes autônomos com loop de raciocínio e execução de ferramentas integrado:

import { Agent } from "@anthropic-ai/agent-sdk";
import fs from "fs";

const agent = new Agent({
  model: "claude-sonnet-4-6",
  instructions: "Você é um assistente de desenvolvimento. Ajude com código TypeScript.",
  tools: [
    {
      name: "read_file",
      description: "Read a file from disk",
      execute: async ({ path }) => fs.readFileSync(path, "utf-8"),
    },
    {
      name: "write_file",
      description: "Write content to a file",
      execute: async ({ path, content }) => {
        fs.writeFileSync(path, content, "utf-8");
        return `File written: ${path}`;
      },
    },
  ],
});

const result = await agent.run("Analise meu package.json e sugira atualizações de dependências");
console.log(result.output);
O Agent SDK lida automaticamente com o loop de tool use — Claude decide quando chamar ferramentas, executa-as e processa os resultados até chegar a uma resposta final.

Diferença: API direta vs Agent SDK

Aspecto API direta Agent SDK
Loop de tool use Manual — você gerencia Automático
Controle Total Abstraído
Código necessário Mais verboso Mais conciso
Ideal para Integrações customizadas, controle fino Agentes autônomos, prototipagem rápida

Exercício: script de análise de código com a API

Objetivo

Crie um script Node.js que usa a API diretamente para analisar automaticamente um arquivo de código e retornar problemas encontrados:

  • Leia um arquivo TypeScript do disco
  • Envie o conteúdo para a Claude API
  • Peça ao Claude para identificar bugs, code smells e melhorias
  • Salve o relatório em analysis-report.json

Solução

import Anthropic from "@anthropic-ai/sdk";
import fs from "fs";

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

async function analyzeFile(filePath: string) {
  const code = fs.readFileSync(filePath, "utf-8");

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: "Você é um code reviewer especializado. Retorne SEMPRE JSON válido.",
    messages: [{
      role: "user",
      content: `Analise este código TypeScript e retorne um JSON com:
{ "bugs": [], "codeSmells": [], "suggestions": [], "score": 0-10 }

\`\`\`typescript
${code}
\`\`\``
    }],
  });

  const report = JSON.parse(response.content[0].text);
  fs.writeFileSync("analysis-report.json", JSON.stringify(report, null, 2));
  console.log(`Análise concluída. Score: ${report.score}/10`);
  return report;
}

analyzeFile(process.argv[2] || "src/index.ts");

Recursos

0%