Build a Lightweight AI Agent That Can Use APIs

mkdir ai-agent
cd ai-agent
npm init -y
npm install openai dotenv

OPENAI_API_KEY=your_key_here
WEATHER_API_KEY=your_weather_api_key
SLACK_TOKEN=your_slack_token

async function getWeather(city) {
  try {
    const res = await fetch(`https://api.weatherapi.com/v1/current.json?key=${process.env.WEATHER_API_KEY}&q=${city}`)
    if (!res.ok) throw new Error(`Weather API returned ${res.status}`)
    const data = await res.json()
    if (!data.current) throw new Error('Invalid response format')
    return `${city} temperature is ${data.current.temp_c}C`
  } catch (error) {
    return `Failed to get weather: ${error.message}`
  }
}

async function sendSlackMessage(message) {
  try {
    const res = await fetch("https://slack.com/api/chat.postMessage", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${process.env.SLACK_TOKEN}`
      },
      body: JSON.stringify({
        channel: "#alerts",
        text: message
      })
    })
    
    const data = await res.json()
    if (!data.ok) throw new Error(`Slack error: ${data.error}`)
    return "Message sent to Slack"
  } catch (error) {
    return `Failed to send Slack message: ${error.message}`
  }
}

const tools = [
  {
    type: "function",
    function: {
      name: "getWeather",
      description: "Get the current weather for a city",
      parameters: {
        type: "object",
        properties: {
          city: { type: "string" }
        },
        required: ["city"]
      }
    }
  },
  {
    type: "function",
    function: {
      name: "sendSlackMessage",
      description: "Send a message to a Slack channel",
      parameters: {
        type: "object",
        properties: {
          message: { type: "string" }
        },
        required: ["message"]
      }
    }
  }
];

// CommonJS version (recommended for beginners)
const OpenAI = require("openai");
require('dotenv').config();

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

async function runAgent(userPrompt) {
  let messages = [{ role: "user", content: userPrompt }];
  const maxTurns = 10; // prevent infinite loops
  
  for (let turn = 0; turn < maxTurns; turn++) {
    try {
      const response = await openai.chat.completions.create({
        model: "gpt-4o-mini",
        messages,
        tools,
      });

      const message = response.choices[0].message;
      messages.push(message);

      if (!message.tool_calls) {
        return message.content;
      }

      for (const toolCall of message.tool_calls) {
        // Parse arguments safely
        let args;
        try {
          args = JSON.parse(toolCall.function.arguments);
        } catch (e) {
          console.error('Invalid JSON from model:', toolCall.function.arguments);
          continue;
        }

        let result;
        if (toolCall.function.name === "getWeather") {
          result = await getWeather(args.city);
        } else if (toolCall.function.name === "sendSlackMessage") {
          result = await sendSlackMessage(args.message);
        } else {
          result = `Unknown tool: ${toolCall.function.name}`;
        }

        messages.push({
          role: "tool",
          tool_call_id: toolCall.id,
          name: toolCall.function.name, // Required field!
          content: result,
        });
      }
    } catch (error) {
      return `Agent error: ${error.message}`;
    }
  }
  
  return "Agent reached maximum turns without completing";
}

// ES Modules version (if you prefer)
/*
import OpenAI from "openai";
import 'dotenv/config';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
// ... rest of the code is the same
*/

// Test with a simple query
runAgent("What's the weather in Abuja today?")
  .then(console.log)
  .catch(console.error);

// Test with multiple tool calls
runAgent("What's the weather in Abuja today? Then post it to #alerts on Slack.")
  .then(console.log)
  .catch(console.error);