🧠Function-Calling-in-AI-Agents : How It Works and Who Supports It

1. 🧑‍💼 Task-Oriented Agents Purpose: Complete a specific task using external tools (e.g. search, code execution, database queries). Examples: • Travel agent: calls search_flights(), book_hotel(). • Customer support bot: calls check_ticket_status(ticket_id). Function Calling Usage: • Calls APIs to fetch/update user data or perform actions.
2. 🧠 Autonomous Reasoning Agents Purpose: Chain thoughts, tools, and decisions to complete complex objectives. Examples: • Agents built using LangChain or AutoGen that can break down goals and use tools (like web search, calculators, or file I/O). Function Calling Usage: • Iteratively selects functions to call based on internal planning and memory.
3. 💻 Developer/Code Agents Purpose: Write, run, debug, and explain code. Examples: • GitHub Copilot Chat with tool use. • FastAPI-based coding assistants with Python tool execution. Function Calling Usage: • run_code(), lint_code(), explain_error().
4. 📊 Data Analyst Agents Purpose: Analyze, visualize, and interpret data. Examples: • Jupyter-integrated data agents. • SQL copilot or data explorer bots. Function Calling Usage: • query_database(query), plot_data(df, chart_type).
5. 🧾 Knowledge Retrieval (RAG) Agents Purpose: Retrieve relevant documents and generate responses using them. Examples: • Legal or medical Q&A agents. • Chatbots with document search (via ColBERT, FAISS, etc.). Function Calling Usage: • search_documents(query), summarize_text(text).
6. 🧬 Multimodal Agents Purpose: Process and combine text, images, audio, and video. Examples: • Radiology AI assistant that reads images and generates reports. • AI that answers questions based on charts or screenshots. Function Calling Usage: • analyze_image(image_path), transcribe_audio(audio).
7. 🤖 Robotic Process Automation (RPA) Agents Purpose: Interact with external apps and simulate human workflows. Examples: • Agents that log into websites, fill forms, or control other software. Function Calling Usage: • click_button(), read_screen(), type_text().
8. 🕵️‍♂️ Search & Web Browsing Agents Purpose: Perform real-time web search, scraping, and summarization. Examples: • GPT-powered agents using Bing or Google tools. • LangChain tools like serpapi_search(). Function Calling Usage: • web_search(query), fetch_url(url), summarize_html(html).

"What’s the weather in Rome?"

1. Install Dependencies

pip install fastapi openai uvicorn python-dotenv

from fastapi import FastAPI, Request
from pydantic import BaseModel
import openai
import json
import os
from dotenv import load_dotenv

load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

app = FastAPI()

# Define a mock function to simulate real weather API
def get_current_weather(location: str):
    return {
        "location": location,
        "temperature": "28°C",
        "condition": "Clear sky",
    }

# Define OpenAI tool schema
functions = [
    {
        "name": "get_current_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "The name of the city"
                }
            },
            "required": ["location"]
        }
    }
]

# Request model
class Query(BaseModel):
    question: str

@app.post("/weather")
async def weather_agent(query: Query):
    user_message = {"role": "user", "content": query.question}

    # Step 1: Ask GPT if a function call is needed
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo-0613",
        messages=[user_message],
        functions=functions,
        function_call="auto"
    )

    choice = response.choices[0].message

    if choice.get("function_call"):
        func_call = choice["function_call"]
        args = json.loads(func_call["arguments"])
        result = get_current_weather(**args)

        # Step 2: Feed function result back into the model
        messages = [
            user_message,
            choice,
            {
                "role": "function",
                "name": func_call["name"],
                "content": json.dumps(result)
            }
        ]

        final = openai.ChatCompletion.create(
            model="gpt-3.5-turbo-0613",
            messages=messages
        )

        return {"response": final.choices[0].message["content"]}
    
    return {"response": choice["content"]}

uvicorn main:app --reload

curl -X POST http://localhost:8000/weather \
-H "Content-Type: application/json" \
-d '{"question": "What’s the weather like in Rome today?"}'

{
  "response": "It's 28°C and clear sky in Rome today."
}

[ User Input ]
     │
     ▼
[ GPT Model ]
     │
     ├── If no function needed → answer directly
     │
     └── If function needed:
           │
           ├── Suggests function + arguments
           ▼
    [ Call Python Function ]
           │
           ▼
    [ Return Function Result ]
           │
           ▼
    [ Model Generates Final Answer ]

User: What's the weather like in Rome ?
AI: It's 22°C and sunny in Riyadh today.