Building Your First AI Agent

const SYSTEM_PROMPT = `You are a professional research analyst. Your job is to research topics thoroughly and produce well-structured reports.

PROCESS:
1. Break the topic into 3-4 key questions to investigate
2. Search for each question using the web_search tool
3. For promising results, use get_page_content to read details
4. Synthesise your findings into a coherent report
5. Use create_report to save the final report

REPORT FORMAT:
- Title
- Executive Summary (2-3 sentences)
- Key Findings (3-5 bullet points with evidence)
- Detailed Analysis (2-3 paragraphs)
- Conclusion (1-2 sentences)
- Sources (list all URLs consulted)

RULES:
- Always cite your sources
- Do not speculate beyond what the sources support
- If a search returns no results, try a different query
- After no more than 12 steps, compile whatever you have found and write the report
`;

const tools = [
  {
    type: 'function',
    function: {
      name: 'web_search',
      description: 'Search the internet for information. Returns a list of relevant URLs and snippets. Use for each key question you identified.',
      parameters: {
        type: 'object',
        properties: {
          query: { type: 'string', description: 'The search query' },
          num_results: { type: 'integer', description: 'Number of results to return (default 5, max 10)', default: 5 }
        },
        required: ['query']
      }
    }
  },
  {
    type: 'function',
    function: {
      name: 'get_page_content',
      description: 'Read the full text content of a webpage. Use after web_search to get detailed information from specific URLs.',
      parameters: {
        type: 'object',
        properties: {
          url: { type: 'string', description: 'The URL to read' },
          max_chars: { type: 'integer', description: 'Maximum characters to return (default 3000)', default: 3000 }
        },
        required: ['url']
      }
    }
  },
  {
    type: 'function',
    function: {
      name: 'create_report',
      description: 'Save the final research report. Use this only when your research is complete and you are ready to write the final report.',
      parameters: {
        type: 'object',
        properties: {
          title: { type: 'string' },
          content: { type: 'string', description: 'The full report in markdown format' }
        },
        required: ['title', 'content']
      }
    }
  }
];

// Run in Node.js -- replace with real implementations
const toolImplementations = {
  web_search: async ({ query, num_results = 5 }) => {
    // In production: call a real search API (Serper, Tavily, Google Custom Search)
    console.log('Searching:', query);

    // Simulated results
    return {
      results: [
        { title: 'Introduction to ' + query, url: 'https://example.com/intro', snippet: 'Comprehensive overview of ' + query + '...' },
        { title: query + ' - Current State', url: 'https://research.example.com/current', snippet: 'Recent developments in ' + query + '...' },
        { title: 'The Future of ' + query, url: 'https://analysis.example.com/future', snippet: 'Expert predictions for ' + query + '...' },
      ].slice(0, num_results)
    };
  },

  get_page_content: async ({ url, max_chars = 3000 }) => {
    // In production: use a headless browser or web scraping service
    console.log('Reading:', url);
    return {
      url,
      content: 'Detailed content from ' + url + '. [In production, this would be the actual page text, truncated to ' + max_chars + ' characters.]',
      word_count: 450
    };
  },

  create_report: async ({ title, content }) => {
    // In production: save to database, Google Docs, Notion, etc.
    console.log('Creating report:', title);
    console.log(content);
    return { success: true, report_id: 'rpt_' + Date.now(), title };
  }
};

import OpenAI from 'openai';

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function runResearchAgent(topic) {
  console.log('Starting research on:', topic);

  const messages = [
    { role: 'system', content: SYSTEM_PROMPT },
    { role: 'user', content: 'Research this topic and produce a comprehensive report: ' + topic }
  ];

  const MAX_ITERATIONS = 15;
  let iteration = 0;
  let finalReport = null;

  while (iteration < MAX_ITERATIONS) {
    iteration++;
    console.log('\n--- Iteration ' + iteration + ' ---');

    const response = await client.chat.completions.create({
      model: 'gpt-4o',
      messages,
      tools,
      tool_choice: 'auto',
      temperature: 0,
    });

    const choice = response.choices[0];

    if (choice.finish_reason === 'stop') {
      // Agent produced a final text response
      console.log('Agent finished:', choice.message.content);
      break;
    }

    if (choice.finish_reason === 'tool_calls') {
      messages.push(choice.message);

      for (const toolCall of choice.message.tool_calls) {
        const fnName = toolCall.function.name;
        const fnArgs = JSON.parse(toolCall.function.arguments);

        console.log('Tool call:', fnName, JSON.stringify(fnArgs));

        try {
          const fn = toolImplementations[fnName];
          if (!fn) throw new Error('Unknown tool: ' + fnName);

          const result = await fn(fnArgs);
          console.log('Tool result:', JSON.stringify(result).substring(0, 200));

          if (fnName === 'create_report') {
            finalReport = { title: fnArgs.title, content: fnArgs.content };
          }

          messages.push({
            role: 'tool',
            tool_call_id: toolCall.id,
            content: JSON.stringify(result)
          });
        } catch (error) {
          messages.push({
            role: 'tool',
            tool_call_id: toolCall.id,
            content: JSON.stringify({ error: error.message, suggestion: 'Try a different approach or tool.' })
          });
        }
      }
    }
  }

  if (iteration >= MAX_ITERATIONS) {
    console.log('Max iterations reached. Requesting final report...');
  }

  return finalReport;
}

// Run the agent
const report = await runResearchAgent('The impact of AI on software engineering jobs');
console.log('\nFinal Report:', report?.title);