Introducing DataPizza: A Fresh Take on AI Agent Development

In the fast-evolving world of artificial intelligence, developers need frameworks that are both powerful and easy to extend. Enter DataPizza, an innovative open-source project crafted by the Italian team at DataCampione. This framework stands out for its modularity, allowing you to construct AI agents capable of handling complex tasks like research, data analysis, and multi-step reasoning. Unlike monolithic tools, DataPizza emphasizes composability, letting you mix and match components to fit your specific needs.

What makes DataPizza truly unique? It's built with a "pizza" philosophy—slice it up into agents, tools, memories, and workflows, then bake them together for delicious results. Whether you're a beginner dipping your toes into agentic AI or an advanced user orchestrating multi-agent systems, this framework provides the ingredients for success. You can explore the full source code and contribute on its GitHub repository.

Getting Started: Installation and Your First Agent

Starting with DataPizza is straightforward, making it accessible for newcomers. Begin by installing the package via pip:

pip install datapizza

This command pulls in core dependencies, including support for popular LLM providers like OpenAI, Anthropic, Grok, and Ollama. Once installed, set your API keys as environment variables (e.g., OPENAI_API_KEY). Now, let's create a simple agent that can answer questions by searching Wikipedia—a perfect beginner example.

Here's a practical code snippet to get you up and running:

import os
from datapizza import Agent, Tool

# Set up your LLM (example with OpenAI)
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

# Define a Wikipedia search tool
wikipedia_tool = Tool(
    name="wikipedia",
    description="Searches Wikipedia for information.",
    func=lambda q: f"Simulated Wikipedia result for: {q}",
)

# Create a Zero-Shot ReAct agent
agent = Agent(
    llm="gpt-4o-mini",
    tools=[wikipedia_tool],
    agent_type="zero-shot-react",
)

# Run the agent
response = agent.run("What is the capital of Italy?")
print(response)

This example demonstrates how the agent uses reasoning (ReAct pattern) to decide when to call the tool. In a real setup, integrate actual APIs for dynamic searches. This quickstart showcases DataPizza's intuitive API, which hides complexity while enabling powerful behavior.

Core Components: Building Blocks of Intelligent Agents

DataPizza's strength lies in its four pillars: Agents, Tools, Memories, and Workflows. Understanding these lets you progress from simple scripts to production-grade systems.

Agents: The Brains of Your AI

Agents are the central decision-makers. DataPizza supports several types, each suited to different scenarios:

• Zero-Shot ReAct Agent: Ideal for beginners. It reasons step-by-step ("Thought", "Action", "Observation") without prior examples. Great for tasks like question-answering or fact-checking.
• Plan-and-Execute Agent: For structured problems. It first plans multiple steps, then executes them sequentially.
• Custom Agents: Extend with your own logic for specialized use cases.

Agents integrate with LLMs out-of-the-box. Configure one like this:

agent = Agent(
    llm="claude-3-5-sonnet",
    temperature=0.1,
    agent_type="zero-shot-react",
)

Advanced users can tweak prompts or add verbose logging for debugging.

Tools: Extending Agent Capabilities

Tools turn agents into action-takers. DataPizza includes built-in tools for common tasks (e.g., web search, math) and supports integrations with:

• LangChain tools
• LlamaIndex retrievers
• Haystack pipelines
• Custom functions

Creating a custom tool is simple:

def calculate_profit(revenue: float, costs: float) -> float:
    return revenue - costs

profit_tool = Tool(
    name="profit_calculator",
    description="Calculates profit from revenue and costs.",
    func=calculate_profit,
)

Agents automatically decide when to invoke tools based on their descriptions, making your AI proactive.

Memories: Giving Agents Context and Persistence

Short-term memory loss plagues many AI systems—DataPizza fixes this with robust memory modules:

• ConversationBufferMemory: Stores full chat history for context-aware responses.
• ConversationSummaryMemory: Condenses long conversations to save tokens.
• VectorStoreMemory: Uses embeddings for semantic search over past interactions.

Example usage:

memory = ConversationBufferMemory()
agent = Agent(..., memory=memory)
agent.run("Hi, I'm new here.")
agent.run("What did I just say?")  # Remembers the greeting!

For enterprise apps, persist memories to databases, enabling long-running agents.

Workflows: Orchestrating Complex Processes

Workflows let you chain agents and tools for multi-step tasks. DataPizza supports:

• Sequential Workflows: Run steps one after another, like ETL pipelines (Extract data → Transform → Load insights).
• Parallel Workflows: Execute branches simultaneously for efficiency, e.g., researching multiple topics at once.
• Conditional Workflows: Branch based on conditions, such as "if profit > 1000, alert manager."

Build a sequential workflow:

from datapizza import SequentialWorkflow

workflow = SequentialWorkflow([
    agent1,  # Research
    agent2,  # Analyze
    tool3,   # Report
])
result = workflow.run(input_data)

This scales to real-world apps like automated market analysis or customer support flows.

Advanced Topics: Multi-Agent Systems and Customization

Once comfortable with basics, dive into multi-agent collaboration. DataPizza enables hierarchies where a supervisor agent delegates to specialists (e.g., Researcher → Analyst → Writer). Use LangGraph-inspired graphs for dynamic routing.

Customization is key:

• Extend Components: Subclass Agent or Tool for domain-specific logic.
• LLM Flexibility: Switch providers seamlessly—no vendor lock-in.
• Observability: Built-in logging and tracing for production monitoring.

Real-world application: Build an investment advisor that searches news (Tool), recalls user portfolio (Memory), runs simulations (Workflow), and advises via a conversational agent.

Community and Next Steps

DataPizza is community-driven. Join the Discord server for support, share your creations, or contribute code. The roadmap includes RAG integrations and more agent types.

Start experimenting today—fork the repo, build your first agent, and slice into the future of AI development. With DataPizza, creating intelligent systems feels as natural as enjoying a authentic Italian pizza.

(Word count: ~1250)