Autonomous Research with Anthropic Tool Use

npm install hono @anthropic-ai/sdk zod

import Anthropic from '@anthropic-ai/sdk';
import { z } from 'zod';
 
const SearchInput = z.object({ query: z.string() });
const GetArticleInput = z.object({ title: z.string() });
const FinishResearchInput = z.object({
  summary: z.string(),
  sourcesUsed: z.number(),
});
 
const WikipediaSearchResponse = z.object({
  query: z
    .object({
      search: z.array(z.object({ title: z.string(), snippet: z.string() })).optional(),
    })
    .optional(),
});
 
const WikipediaExtractResponse = z.object({
  query: z
    .object({
      pages: z.record(z.string(), z.object({ extract: z.string().optional() })).optional(),
    })
    .optional(),
});
 
const tools: Anthropic.Tool[] = [
  {
    name: 'search_wikipedia',
    description: 'Search Wikipedia for articles matching a query. Returns titles and snippets.',
    input_schema: {
      type: 'object',
      properties: { query: { type: 'string', description: 'The search query' } },
      required: ['query'],
    },
  },
  {
    name: 'get_article',
    description: 'Get the introductory text of a Wikipedia article by title.',
    input_schema: {
      type: 'object',
      properties: { title: { type: 'string', description: 'Exact article title' } },
      required: ['title'],
    },
  },
  {
    name: 'finish_research',
    description: 'Call when you have enough information to write a 2-3 paragraph summary.',
    input_schema: {
      type: 'object',
      properties: {
        summary: { type: 'string' },
        sourcesUsed: { type: 'number' },
      },
      required: ['summary', 'sourcesUsed'],
    },
  },
];

async function searchWikipedia(query: string): Promise<string> {
  const url = `https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query)}&format=json&origin=*&srlimit=3`;
  const res = await fetch(url);
  if (!res.ok) return `Search failed: HTTP ${res.status}`;
 
  const parsed = WikipediaSearchResponse.safeParse(await res.json());
  if (!parsed.success) return 'No results found.';
 
  const results = parsed.data.query?.search ?? [];
  if (results.length === 0) return 'No results found.';
 
  return JSON.stringify(
    results.map((r) => ({ title: r.title, snippet: r.snippet.replace(/<[^>]*>/g, '') }))
  );
}
 
async function getArticle(title: string): Promise<string> {
  const url = `https://en.wikipedia.org/w/api.php?action=query&titles=${encodeURIComponent(title)}&prop=extracts&exintro=true&explaintext=true&format=json&origin=*`;
  const res = await fetch(url);
  if (!res.ok) return `Failed to fetch article: HTTP ${res.status}`;
 
  const parsed = WikipediaExtractResponse.safeParse(await res.json());
  if (!parsed.success) return 'No content found.';
 
  const pages = parsed.data.query?.pages;
  if (!pages) return 'No content found.';
  const [page] = Object.values(pages);
  return page?.extract ?? 'No content found.';
}
 
async function executeTool(name: string, input: unknown): Promise<string> {
  switch (name) {
    case 'search_wikipedia': {
      const { query } = SearchInput.parse(input);
      return searchWikipedia(query);
    }
    case 'get_article': {
      const { title } = GetArticleInput.parse(input);
      return getArticle(title);
    }
    default:
      return `Unknown tool: ${name}`;
  }
}

const SYSTEM_PROMPT = `You are a research assistant that investigates topics using Wikipedia.
 
Follow this loop:
1. Plan: decide what to search for next
2. Search: call search_wikipedia
3. Read: call get_article on the most relevant result
4. Finish: when you have enough (usually 2-4 sources), call finish_research`;
 
const MAX_STEPS = 8;
const client = new Anthropic();
const model = process.env.ANTHROPIC_MODEL;
 
if (!model) {
  throw new Error('Set ANTHROPIC_MODEL to the model this workflow should use.');
}
 
interface ResearchResult {
  readonly summary: string;
  readonly sourcesUsed: number;
}
 
export async function research(topic: string): Promise<ResearchResult> {
  const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: `Research this topic thoroughly: ${topic}` },
  ];
 
  for (let step = 0; step < MAX_STEPS; step++) {
    const response = await client.messages.create({
      model,
      max_tokens: 4096,
      system: SYSTEM_PROMPT,
      tools,
      messages,
    });
 
    if (response.stop_reason !== 'tool_use') break;
 
    messages.push({ role: 'assistant', content: response.content });
 
    const toolResults: Anthropic.ToolResultBlockParam[] = [];
    let finalResult: ResearchResult | undefined;
 
    for (const block of response.content) {
      if (block.type !== 'tool_use') continue;
 
      if (block.name === 'finish_research') {
        finalResult = FinishResearchInput.parse(block.input);
        continue;
      }
 
      const result = await executeTool(block.name, block.input);
      toolResults.push({ type: 'tool_result', tool_use_id: block.id, content: result });
    }
 
    if (finalResult) {
      return finalResult;
    }
 
    messages.push({ role: 'user', content: toolResults });
  }
 
  return { summary: 'Research could not be completed. Try a more specific topic.', sourcesUsed: 0 };
}

import { Hono } from 'hono';
import { research } from './lib/research-agent';
import { z } from 'zod';
 
const requestSchema = z.object({ topic: z.string() });
 
const app = new Hono();
 
app.post('/api/research', async (c) => {
  const body: unknown = await c.req.json();
  const { topic } = requestSchema.parse(body);
  const result = await research(topic);
  return c.json(result);
});
 
export default app;