Unlock Data Insights: Dynamically Generate and Execute Tools with o3-mini

Tired of predefined functions limiting your LLM's potential? Discover how to build AI-powered applications that adapt and solve complex problems by dynamically generating and executing tools using o3-mini. This article will guide you through creating a custom code interpreter for data analysis, visualization, and more, boosting your AI's capabilities and flexibility.

What is Dynamic Tool Generation?

Dynamic tool generation empowers Large Language Models (LLMs) to create functions or code blocks on the fly, in real-time, based on user prompts.

• Flexibility: No need to predefine every possible scenario.
• Creativity: LLMs can adapt to new and unexpected tasks.
• Adaptive Problem-Solving: Addresses complex issues with innovative solutions.

Unleash o3-mini's Code Interpretation Power

The o3-mini model, released on January 31, 2025, excels in science, math, and coding. It delivers robust STEM capabilities with low cost and reduced latency. Using o3-mini to generate Python code and dynamically interpret data allows unparalleled analysis and insight extraction.

Why Build a Custom Code Interpreter?

While pre-built code interpreters like OpenAI's Assistants API offer convenience, custom solutions provide key advantages:

• Language & Library Support: Utilize specific programming languages (C++, Java) or libraries not supported by standard interpreters.
• Task Compatibility: Overcome limitations imposed by provider’s built-in solutions.
• Model Freedom: Use the exact language model needed for your task.
• Cost-Effectiveness: Control code execution costs and model usage.
• Data Handling: Process large or unsupported file sizes.
• System Integration: Seamlessly connect with existing internal systems.

Furthermore, the ability to generate functions on the fly is part of a broader trend on the future of using AI as a code interpreter.

Constructing a Dynamic Tool Calling Application

This comprehensive guide walks through building an agentic application with dynamic tool calling to answer diverse questions such as:

• "What factors contribute the most to accident frequency?"
• "Which areas are at the highest risk of accidents?"
• "How does traffic fine amount influence the number of accidents?"

(We'll be working with sample data related to factors influincing traffic accidents.)

Key Steps to Dynamic Tool Generation

Here's how to build an agentic application with dynamically generated tool calling:

1. Set Up an Isolated Code Execution Container:

• Use Docker to create a secure environment for running LLM-generated code.
• Restrict resource access to prevent unintended consequences.
• Consider this a best pratice, the container cannot access the host machine’s file system.

2. Define and Test Agents:

• Agent Definition: Agent is a set of instructions for the LLM, a LLM model and tool call access to a function and ability to execute the function.
• FileAccessAgent: Reads files, extracts context, and uses GPT-4o Model.
• PythonCodeExecAgent: Generates and executes Python code, leverages the o3-mini model, and uses a Code Interpreter Tool.

3. Establish Agentic Orchestration:

• Design a workflow where agents are called in sequence to complete a task.
• The PythonExecAgent will generate the Python code to answer the user's question and execute the code in the Docker container.

Prerequisites

Before diving in, ensure you have the following:

• Docker: Installed and running.
• Python: Installed on your local machine.
• OpenAI API Key: Configured as an environment variable.

Detailed Breakdown: Step-by-Step

Step 1: Isolated Code Execution Environment

1. Define a Dockerfile specifying Python 3.10 (or the desired language).
2. Preinstall necessary packages in requirements.txt.
3. Build the Docker image:

   docker build -t python_sandbox:latest ./resources/docker 2>&1 | grep -E "View build details|ERROR" || echo "Build failed."
   

   Copy
4. Run the container in restricted mode:

   docker run -d --name sandbox --network none --cap-drop all --pids-limit 64 --tmpfs /tmp:rw,size=64M python_sandbox:latest sleep infinity
   

   Copy
5. Verify the container is running: docker ps.

Step 2: Agent Definition and Testing

1. FileAccessAgent (Pre-defined Tool Calling):

   • Provides instructions to understand a file's content.
   • Accesses the host machine's file system.
   • Uses the gpt-4o model.

2. PythonCodeExecAgent (Dynamically Generated Tool Calling):

   • Receives file context from Agent 1.
   • Generates Python code to answer user questions.
   • Accesses the code interpreter within the Docker container.
   • Uses the o3-mini model.

   This separation is critical to limiting the LLM from directly accessing or modifying the host machine.

Core Classes for Consistency:

• BaseAgent: Abstract base class enforcing common method signatures.
• ChatMessages: Class to store conversation history (ChatCompletions API is stateless).
• ToolManager: Class to manage tools available to an agent.
• ToolInterface: Abstract class providing a consistent interface for all tools.

Code examples for setting up FileAccessAgent and PythonCodeExecAgent are also provided in the original documentation.

Step 3: Agentic Orchestration

1. Prompt the user for a question.
2. FileAccessAgent reads the file and provides context.
3. PythonExecAgent generates and executes code within the Docker container.
4. Display results to the user.

Conclusion: Embracing Dynamic Tool Generation

By following this guide, you can build a powerful, adaptable AI application using dynamic tool generation with o3-mini. This approach unlocks new possibilities for data analysis, automation, and creative problem-solving, making your AI more versatile and effective.