bashnpm install @anthropic-ai/sdk
# or
pip install anthropic

bashexport ANTHROPIC_API_KEY="sk-ant-..."

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

const client = new Anthropic();

// Define the tool Claude can use
const tools: Anthropic.Tool[] = [
  {
    name: "get_weather",
    description:
      "Get the current weather for a city. Returns temperature and conditions.",
    input_schema: {
      type: "object" as const,
      properties: {
        city: {
          type: "string",
          description: "The city name, e.g. 'San Francisco'",
        },
      },
      required: ["city"],
    },
  },
];

// Mock tool implementation (replace with real API call)
function getWeather(city: string) {
  const mockData: Record<string, string> = {
    "San Francisco": "62°F, partly cloudy",
    "New York": "71°F, sunny",
    London: "55°F, overcast",
  };
  return mockData[city] ?? "Weather data unavailable for this city.";
}

// The agent loop
async function runAgent(userMessage: string) {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];

  console.log(`User: ${userMessage}\n`);

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

    // If Claude decides to use a tool
    if (response.stop_reason === "tool_use") {
      const toolUseBlock = response.content.find(
        (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
      );

      if (!toolUseBlock) break;

      console.log(`Claude is calling: ${toolUseBlock.name}`);
      console.log(`With input: ${JSON.stringify(toolUseBlock.input)}\n`);

      // Execute the tool
      const toolResult =
        toolUseBlock.name === "get_weather"
          ? getWeather((toolUseBlock.input as { city: string }).city)
          : "Tool not found";

      console.log(`Tool result: ${toolResult}\n`);

      // Add the assistant's tool call + result to the conversation
      messages.push({ role: "assistant", content: response.content });
      messages.push({
        role: "user",
        content: [
          {
            type: "tool_result",
            tool_use_id: toolUseBlock.id,
            content: toolResult,
          },
        ],
      });

      // Loop again — Claude will now process the tool result
    } else {
      // Claude is done — extract and print the final answer
      const textBlock = response.content.find(
        (block): block is Anthropic.TextBlock => block.type === "text"
      );
      console.log(`Claude: ${textBlock?.text}`);
      break;
    }
  }
}

// Run it
runAgent("What's the weather like in San Francisco and London today?");

typescriptconst researchTools: Anthropic.Tool[] = [
  {
    name: "web_search",
    description: "Search the web for information on a topic. Returns top results.",
    input_schema: {
      type: "object" as const,
      properties: {
        query: { type: "string", description: "The search query" },
        num_results: {
          type: "number",
          description: "Number of results to return (default 5)",
        },
      },
      required: ["query"],
    },
  },
  {
    name: "read_url",
    description: "Fetch and read the content of a URL.",
    input_schema: {
      type: "object" as const,
      properties: {
        url: { type: "string", description: "The URL to fetch" },
      },
      required: ["url"],
    },
  },
  {
    name: "write_file",
    description: "Write content to a local file.",
    input_schema: {
      type: "object" as const,
      properties: {
        filename: { type: "string", description: "The file path to write to" },
        content: { type: "string", description: "The content to write" },
      },
      required: ["filename", "content"],
    },
  },
];

typescriptasync function executeTool(
  name: string,
  input: Record<string, unknown>
): Promise<string> {
  switch (name) {
    case "web_search":
      return await searchWeb(input.query as string, (input.num_results as number) ?? 5);
    case "read_url":
      return await fetchUrl(input.url as string);
    case "write_file":
      return await writeFile(input.filename as string, input.content as string);
    default:
      throw new Error(`Unknown tool: ${name}`);
  }
}

typescriptconst systemPrompt = `You are a helpful research assistant.

MEMORY (from previous sessions):
${userMemory.join("\n")}

When you learn something important about the user or task, 
say "REMEMBER: [fact]" and it will be saved for next time.`;

typescript// On each user message:
const relevantMemories = await vectorDB.search(userMessage, { topK: 5 });
const memoryContext = relevantMemories.map((m) => m.text).join("\n");

// Inject only the relevant memories into the system prompt

You are [agent name], a [role] for [company/purpose].

CAPABILITIES:
- You have access to these tools: [list with one-line descriptions]

BEHAVIOR RULES:
1. Always think step-by-step before acting
2. Use tools only when necessary — don't call a tool if you already know the answer
3. If a tool fails, try an alternative approach before giving up
4. Never make up data — if you don't have it, say so

TASK FORMAT:
When given a complex task:
1. Restate the goal in your own words
2. List the steps you plan to take
3. Execute, checking results at each step
4. Summarize what you did and what you found

LIMITS:
- Do not write to any path outside of /output/
- Do not make more than 10 tool calls per task
- Stop and ask for clarification if the task is ambiguous

typescriptasync function robustAgentLoop(
  userMessage: string,
  maxIterations = 15
): Promise<string> {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];
  let iterations = 0;

  while (iterations < maxIterations) {
    iterations++;

    try {
      const response = await client.messages.create({
        model: "claude-opus-4-6",
        max_tokens: 4096,
        tools,
        messages,
      });

      if (response.stop_reason === "max_tokens") {
        // Claude ran out of tokens mid-response — increase max_tokens or summarize context
        console.warn("Hit token limit — consider summarizing the conversation");
        break;
      }

      if (response.stop_reason === "tool_use") {
        // Process all tool calls in this response (Claude may call multiple tools at once)
        const toolUseBlocks = response.content.filter(
          (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
        );

        const toolResults = await Promise.all(
          toolUseBlocks.map(async (block) => {
            try {
              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,
              };
            } catch (err) {
              // Return error as tool result — let Claude decide what to do
              return {
                type: "tool_result" as const,
                tool_use_id: block.id,
                content: `Error: ${err instanceof Error ? err.message : "Unknown error"}`,
                is_error: true,
              };
            }
          })
        );

        messages.push({ role: "assistant", content: response.content });
        messages.push({ role: "user", content: toolResults });
      } else {
        // end_turn — extract final response
        const textBlock = response.content.find(
          (block): block is Anthropic.TextBlock => block.type === "text"
        );
        return textBlock?.text ?? "No response generated.";
      }
    } catch (err) {
      // API error — could be rate limit, network issue, etc.
      if ((err as { status?: number }).status === 429) {
        console.log("Rate limited — waiting 30s...");
        await new Promise((resolve) => setTimeout(resolve, 30000));
      } else {
        throw err;
      }
    }
  }

  return "Agent reached maximum iterations without completing the task.";
}