Local AI with Ollama

[Local AI with Ollama] Building a Function-Calling LLM App for Electronics Categorization with Ollama

In this section, you'll learn how to build a hands-on function calling workflow with Ollama, allowing your LLM to interact with external Python functions/tools. We'll walk through a practical scenario: categorizing a list of electronics items, fetching price and technical specifications for each item, and finally generating a recommendation for a random category. Below, you'll find the full, runnable code and a detailed explanation of each step.

Why Function Calling Matters for LLMs

Large language models (LLMs) are powerful but limited by their training data. This means they can't access up-to-date or external information, and can even "hallucinate" facts. To address this, function calling lets an LLM use external tools or APIs to fetch real-world data and perform actions it couldn't do by itself. In this example, we empower the model to:

  • Categorize a list of electronics items.
  • Fetch price and specifications data for each item via tool calling.
  • Fetch a recommendation for a random electronics category.

Environment Setup

Before writing any code, make sure you have the required Python environment and packages installed.

python3 -m venv venv
source venv/bin/activate  # On Windows use venv\Scripts\activate

# Install the required package
pip install ollama

Setting Up: Defining Tools and Functions

We'll define three main Python functions:

  • load_electronics_list: Loads items from a text file.
  • fetch_price_and_specs: Returns fake price/specification data (you could connect to a real API).
  • fetch_recommendation: Returns a fake recommendation based on a category (also can be replaced with a real API).

We also define tool metadata so the LLM knows how to call these functions.

import os
import json
import asyncio
import random
from ollama import AsyncClient

# Load the electronics list from a text file
def load_electronics_list(file_path):
    if not os.path.exists(file_path):
        print(f"File {file_path} does not exist.")
        return []
    with open(file_path, "r") as file:
        items = [line.strip() for line in file if line.strip()]
    return items

# Function to fetch price and specifications data for an item
async def fetch_price_and_specs(item):
    print(f"Fetching price and specs for '{item}'...")
    # Replace with actual API calls
    await asyncio.sleep(0.1)  # Simulate network delay
    return {
        "item": item,
        "price": f"${random.uniform(50, 2000):.2f}",
        "RAM": f"{random.choice([4, 8, 16, 32, 64])} GB",
        "Storage": f"{random.choice([128, 256, 512, 1024])} GB",
        "Processor": random.choice(["Intel i5", "Intel i7", "M1", "Ryzen 7", "Snapdragon"]),
    }

# Function to fetch a recommendation based on a category
async def fetch_recommendation(category):
    print(f"Fetching a recommendation for the '{category}' category...")
    # Replace with actual API calls to a recommendation service
    await asyncio.sleep(0.1)  # Simulate network delay
    return {
        "category": category,
        "recommendation": f"Top rated {category} device",
        "details": "This device offers the best balance between performance and price.",
    }

Full Pipeline: Categorize, Call Tools, and Process Results

The main function orchestrates the flow:

  • Loads the electronics list.
  • Defines the tool metadata for the LLM.
  • Sends a prompt to categorize items.
  • Instructs the model to call the price/specs function for each item.
  • Has the model call the recommendation function for a random category.
  • Maintains conversation history for multi-turn interactions.
async def main():
    # Load electronics list
    electronics_items = load_electronics_list("./data/electronics_list.txt")
    if not electronics_items:
        print("Electronics list is empty or file not found.")
        return

    # Initialize Ollama client
    client = AsyncClient()

    # Define the functions (tools) for the model
    tools = [
        {
            "type": "function",
            "function": {
                "name": "fetch_price_and_specs",
                "description": "Fetch price and specification data for an electronics item",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "item": {
                            "type": "string",
                            "description": "The name of the electronics item",
                        },
                    },
                    "required": ["item"],
                },
            },
        },
        {
            "type": "function",
            "function": {
                "name": "fetch_recommendation",
                "description": "Fetch a recommendation based on an electronics category",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "category": {
                            "type": "string",
                            "description": "The category of electronics (e.g., Laptop, Smartphone, Tablet)",
                        },
                    },
                    "required": ["category"],
                },
            },
        },
    ]

    # Step 1: Categorize items using the model
    categorize_prompt = f"""
You are an assistant that categorizes electronics items.

Instructions:

- Return the result only as a valid JSON object.
- Do not include any explanations, greetings, or additional text.
- Use double quotes (`"`) for all strings.
- Ensure the JSON is properly formatted.
- The JSON should have categories as keys and lists of items as values.

Example Format:

{{
  "Laptop": ["MacBook Air", "Dell XPS 13"],
  "Smartphone": ["iPhone 14", "Samsung Galaxy S23"]
}}

Electronics Items:

{', '.join(electronics_items)}
"""

    messages = [{"role": "user", "content": categorize_prompt}]
    # First API call: Categorize items
    response = await client.chat(
        model="llama3.2",
        messages=messages,
        tools=tools,  # No function calling needed here, but included for consistency
    )

    # Add the model's response to the conversation history
    messages.append(response["message"])
    print(response["message"]["content"])

    # Parse the model's response
    assistant_message = response["message"]["content"]

    try:
        categorized_items = json.loads(assistant_message)
        print("Categorized items:")
        print(categorized_items)

    except json.JSONDecodeError:
        print("Failed to parse the model's response as JSON.")
        print("Model's response:")
        print(assistant_message)
        return

    # Step 2: Fetch price and specification data using function calling

    fetch_prompt = """
    For each item in the electronics list, use the 'fetch_price_and_specs' function to get its price and specification data.
    """
    messages.append({"role": "user", "content": fetch_prompt})

    # Second API call: The model should decide to call the function for each item
    response = await client.chat(
        model="llama3.2",
        messages=messages,
        tools=tools,
    )
    messages.append(response["message"])

    # Process function calls made by the model
    if response["message"].get("tool_calls"):
        print("Function calls made by the model:")
        available_functions = {
            "fetch_price_and_specs": fetch_price_and_specs,
        }
        item_details = []
        for tool_call in response["message"]["tool_calls"]:
            function_name = tool_call["function"]["name"]
            arguments = tool_call["function"]["arguments"]
            function_to_call = available_functions.get(function_name)
            if function_to_call:
                result = await function_to_call(arguments)
                messages.append(
                    {
                        "role": "tool",
                        "content": json.dumps(result),
                    }
                )
                item_details.append(result)

                print(item_details)
    else:
        print(
            "The model didn't make any function calls for fetching price and specification data."
        )
        return

    # Step 3: Fetch a recommendation for a random category using function calling

    # Choose a random category
    random_category = random.choice(list(categorized_items.keys()))
    recommendation_prompt = f"""
    Fetch a recommendation for the '{random_category}' category using the 'fetch_recommendation' function.
    """
    messages.append({"role": "user", "content": recommendation_prompt})

    # Third API call: The model should decide to call the 'fetch_recommendation' function
    response = await client.chat(
        model="llama3.2",
        messages=messages,
        tools=tools,
    )

    messages.append(response["message"])
    # Process function calls made by the model
    if response["message"].get("tool_calls"):
        available_functions = {
            "fetch_recommendation": fetch_recommendation,
        }
        for tool_call in response["message"]["tool_calls"]:
            function_name = tool_call["function"]["name"]
            arguments = tool_call["function"]["arguments"]
            function_to_call = available_functions.get(function_name)
            if function_to_call:
                result = await function_to_call(arguments)
                messages.append(
                    {
                        "role": "tool",
                        "content": json.dumps(result),
                    }
                )
    else:
        print("The model didn't make any function calls for fetching a recommendation.")
        return

    # Final API call: Get the assistant's final response
    final_response = await client.chat(
        model="llama3.2",
        messages=messages,
        tools=tools,
    )

    print("\nAssistant's Final Response:")
    print(final_response["message"]["content"])

# Run the async main function
asyncio.run(main())

Run the Script

python3 function-calling.py

The result will look like this:

This example shows how function calling can transform an LLM into a powerful agent that interacts with real-world data. With just a few simple tools, you can enable your model to categorize, fetch information, and give contextual recommendations — all running locally with Ollama.