How AI Agent Frameworks Wire In Tools and Agents

from langchain.tools import tool

@tool
def search_database(query: str, limit: int = 10) -> str:
    """Search the customer database for records matching the query.

    Args:
        query: Search terms to look for
        limit: Maximum number of results to return
    """
    return f"Found {limit} results for '{query}'"

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

agent = create_agent(
    ChatOpenAI(model="gpt-5.4"),
    tools=[search_database],
    system_prompt="You are a helpful assistant.",
)
agent.invoke({"messages": [
    {"role": "user", "content": "find acme orders"},
]})

from langgraph.prebuilt import create_react_agent

def check_weather(location: str) -> str:
    '''Return the weather forecast for the specified location.'''
    return f"It's always sunny in {location}"

graph = create_react_agent(
    "anthropic:claude-3-7-sonnet-latest",
    tools=[check_weather],
    prompt="You are a helpful assistant",
)
for chunk in graph.stream(
    {"messages": [{"role": "user", "content": "weather in sf"}]},
    stream_mode="updates",
):
    print(chunk)

from langgraph.graph import StateGraph, MessagesState, START
from langgraph.prebuilt import ToolNode, tools_condition

builder = StateGraph(MessagesState)
builder.add_node("llm", call_llm)
builder.add_node("tools", ToolNode([check_weather]))
builder.add_edge(START, "llm")
builder.add_conditional_edges("llm", tools_condition)
builder.add_edge("tools", "llm")
graph = builder.compile()

from crewai.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type

class MyToolInput(BaseModel):
    """Input schema for MyCustomTool."""
    argument: str = Field(..., description="Description of the argument.")

class MyCustomTool(BaseTool):
    name: str = "Name of my tool"
    description: str = "What this tool does. It's vital for effective utilization."
    args_schema: Type[BaseModel] = MyToolInput

    def _run(self, argument: str) -> str:
        return "Tool's result"

from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool, WebsiteSearchTool

researcher = Agent(
    role='Market Research Analyst',
    goal='Provide up-to-date market analysis.',
    backstory='An expert analyst with a keen eye for trends.',
    tools=[SerperDevTool(), WebsiteSearchTool()],
)

research = Task(
    description='Research the latest trends in the AI industry.',
    expected_output='Top 3 trending developments with significance.',
    agent=researcher,
)

crew = Crew(agents=[researcher], tasks=[research], planning=True)
crew.kickoff()

from google.adk.agents import LlmAgent

def get_weather(location: str) -> dict:
    """Return the current weather for a city."""
    return {"location": location, "tempC": 22, "conditions": "sunny"}

weather_agent = LlmAgent(
    name="weather_agent",
    model="gemini-2.0-flash",
    instruction="Use the get_weather tool to answer weather questions.",
    tools=[get_weather],   # auto-wrapped as FunctionTool
)

from google.adk.agents import LlmAgent, SequentialAgent
from google.adk.tools import ToolContext

def check_and_transfer(query: str, tool_context: ToolContext) -> str:
    """Inspect the query and delegate to support if urgent."""
    if "urgent" in query.lower():
        tool_context.actions.transfer_to_agent = "support_agent"
        return "Transferring to support."
    return "No transfer needed."

coordinator = LlmAgent(
    name="coordinator",
    model="gemini-2.0-flash",
    tools=[check_and_transfer],
    sub_agents=[support_agent],
)

pipeline = SequentialAgent(
    name="pipeline",
    sub_agents=[coordinator, summariser_agent],
)

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function

class WeatherPlugin:
    @kernel_function(name="get_weather", description="Gets the weather for a city")
    def get_weather(self, city: str) -> str:
        return f"It is sunny in {city}."

kernel = Kernel()
kernel.add_service(OpenAIChatCompletion(service_id="default"))
kernel.add_plugin(WeatherPlugin(), plugin_name="weather")

from semantic_kernel.agents import ChatCompletionAgent
from semantic_kernel.connectors.ai.function_choice_behavior import FunctionChoiceBehavior

agent = ChatCompletionAgent(
    kernel=kernel,
    name="WeatherAssistant",
    instructions="Help the user with weather questions.",
    function_choice_behavior=FunctionChoiceBehavior.Auto(),
)

import { createTool } from '@mastra/core/tools'
import { z } from 'zod'

export const weatherTool = createTool({
  id: 'weather-tool',
  description: 'Fetches weather for a location',
  inputSchema:  z.object({ location: z.string() }),
  outputSchema: z.object({ weather:  z.string() }),
  execute: async (inputData) => {
    const { location } = inputData
    const res = await fetch(`https://wttr.in/${location}?format=3`)
    return { weather: await res.text() }
  },
})

import { Agent } from '@mastra/core/agent'
import { weatherTool } from '../tools/weather-tool'

const writer = new Agent({
  id: 'writer', name: 'Writer',
  description: 'Drafts and edits written content',
  instructions: 'You are a skilled writer.',
  model: 'openai/gpt-5.4',
})

export const supervisor = new Agent({
  id: 'supervisor', name: 'Supervisor',
  instructions: 'Coordinate the writer and fetch weather.',
  model: 'openai/gpt-5.4',
  tools:  { weatherTool },
  agents: { writer },   // auto-exposed as "agent-writer"
})

using System.ComponentModel;

[Description("Get the weather for a given location.")]
static string GetWeather(
    [Description("The location to get the weather for.")] string location)
    => $"The weather in {location} is cloudy with a high of 15°C.";

using Azure.AI.Projects;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Extensions.AI;

AIAgent agent = new AIProjectClient(
        new Uri("<your-foundry-project-endpoint>"),
        new DefaultAzureCredential())
    .AsAIAgent(
        model: "gpt-4o-mini",
        instructions: "You are a helpful assistant",
        tools: [ AIFunctionFactory.Create(GetWeather) ]);

Console.WriteLine(
    await agent.RunAsync("What is the weather like in Amsterdam?"));

import dev.langchain4j.agent.tool.Tool;

static class Calculator {

    @Tool("Calculates the length of a string")
    int stringLength(String s) {
        return s.length();
    }

    @Tool("Calculates the sum of two numbers")
    int add(int a, int b) {
        return a + b;
    }
}

import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.service.AiServices;

interface Assistant {
    String chat(String userMessage);
}

Assistant assistant = AiServices.builder(Assistant.class)
    .chatModel(model)
    .tools(new Calculator())
    .chatMemory(MessageWindowChatMemory.withMaxMessages(10))
    .build();

String answer = assistant.chat(
    "What is the square root of the length of 'hello'?");

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/firebase/genkit/go/ai"
    "github.com/firebase/genkit/go/genkit"
    "github.com/firebase/genkit/go/plugins/googlegenai"
)

type WeatherInput struct {
    Location string `json:"location" jsonschema_description:"Location to get weather for"`
}

func main() {
    ctx := context.Background()
    g := genkit.Init(ctx,
        genkit.WithPlugins(&googlegenai.GoogleAI{}),
        genkit.WithDefaultModel("googleai/gemini-1.5-flash"),
    )

    getWeatherTool := genkit.DefineTool(
        g, "getWeather", "Gets the current weather in a given location",
        func(ctx *ai.ToolContext, input WeatherInput) (string, error) {
            return fmt.Sprintf("It is 63°F and sunny in %s.", input.Location), nil
        },
    )

    resp, err := genkit.Generate(ctx, g,
        ai.WithPrompt("What is the weather in San Francisco?"),
        ai.WithTools(getWeatherTool),
    )
    if err != nil { log.Fatal(err) }
    fmt.Println(resp.Text())
}

use rig_derive::rig_tool;

#[rig_tool(
    description = "Perform basic arithmetic operations",
    required(x, y, operation)
)]
fn calculator(
    x: i32, y: i32, operation: String,
) -> Result<i32, rig::tool::ToolError> {
    match operation.as_str() {
        "add"      => Ok(x + y),
        "subtract" => Ok(x - y),
        "multiply" => Ok(x * y),
        "divide" if y != 0 => Ok(x / y),
        "divide"   => Err(rig::tool::ToolError::ToolCallError(
            "Division by zero".into())),
        _ => Err(rig::tool::ToolError::ToolCallError(
            format!("Unknown operation: {operation}").into())),
    }
}

let agent = client
    .agent("gpt-5.2")
    .preamble("You are a calculator.")
    .tool(Adder)
    .tool(Subtract)
    .build();

// Share a tool server between multiple agents
use rig::tool::server::{ToolServer, ToolServerHandle};

let tool_server: ToolServerHandle = ToolServer::new()
    .tool(Adder)
    .run();