LLM Agent: Evolving from Chatbots to Intelligent Assistants

Let the LLM Call External Functions

import json
from typing import List, Dict, Any

class FunctionCallingAgent:
    """Agent based on Function Calling"""
    
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key)
        self.functions = []
        self.function_map = {}
    
    def register_function(self, func, description: str, parameters: Dict):
        """Register a callable function"""
        function_spec = {
            "name": func.__name__,
            "description": description,
            "parameters": parameters
        }
        
        self.functions.append(function_spec)
        self.function_map[func.__name__] = func
    
    def run(self, user_input: str):
        """Execute user request"""
        messages = [
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": user_input}
        ]
        
        # First call: decide whether to use a function
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=messages,
            functions=self.functions,
            function_call="auto"
        )
        
        message = response.choices[0].message
        
        # Check if a function call is needed
        if message.function_call:
            # Parse function call
            function_name = message.function_call.name
            function_args = json.loads(message.function_call.arguments)
            
            # Execute function
            if function_name in self.function_map:
                function_result = self.function_map[function_name](**function_args)
                
                # Add function result to the conversation
                messages.append(message)
                messages.append({
                    "role": "function",
                    "name": function_name,
                    "content": str(function_result)
                })
                
                # Second call: generate the final reply based on function result
                final_response = self.client.chat.completions.create(
                    model="gpt-4",
                    messages=messages
                )
                
                return final_response.choices[0].message.content
        
        return message.content

# Define tool functions
def get_weather(location: str, unit: str = "celsius"):
    """Get weather information"""
    # Should call a real weather API
    return f"Weather in {location}: Sunny, 25 {unit}"

def calculate(expression: str):
    """Calculate a math expression"""
    try:
        result = eval(expression)
        return f"Result: {result}"
    except:
        return "Calculation error"

def search_database(query: str, table: str):
    """Query a database"""
    # Should execute a real database query
    return f"Query '{query}' from table {table}: ..."

# Create agent and register functions
agent = FunctionCallingAgent(api_key="your-key")

agent.register_function(
    get_weather,
    "Get weather information for a specified location",
    {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "Location name"
            },
            "unit": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["location"]
    }
)

agent.register_function(
    calculate,
    "Calculate a mathematical expression",
    {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Mathematical expression"
            }
        },
        "required": ["expression"]
    }
)

# Use the agent
result = agent.run("What is the weather like in Beijing?")
print(result)  # Automatically calls get_weather

result = agent.run("Calculate 123 * 456 + 789")
print(result)