phidata

Phidata constructs autonomous agents that integrate language models, tools, and persistent memory through a unified Agent class that manages conversation state, tool execution context, and multi-turn reasoning. The framework uses a message-passing architecture where agents maintain a session-scoped memory store (supporting file, database, and vector backends) and execute tool calls via a registry-based function binding system that maps LLM outputs to executable Python functions with automatic schema inference.

Phidata provides a Knowledge class that enables agents to retrieve relevant context from external documents via semantic search, using embeddings to match user queries against a vector-indexed knowledge base. The framework supports multiple knowledge sources (PDFs, web pages, databases) and integrates with vector stores (Pinecone, Weaviate, Chroma) to enable retrieval-augmented generation (RAG) where agent reasoning is grounded in retrieved documents rather than relying solely on model weights.

Phidata provides built-in logging and monitoring capabilities that track agent execution, including tool calls, LLM interactions, memory access, and reasoning steps. The framework generates detailed execution traces that can be exported for debugging, auditing, or performance analysis, with support for structured logging and external monitoring integrations.

Phidata supports multi-agent systems where multiple specialized agents coordinate to solve complex problems. The framework provides mechanisms for agents to communicate, delegate tasks, and share knowledge through a common message bus and shared memory layer, enabling hierarchical and collaborative agent architectures.

Phidata implements a tool registry pattern where developers define tools as Python functions with type hints, which are automatically converted to JSON schemas for LLM function-calling APIs (OpenAI, Anthropic, Ollama). The framework handles schema generation, parameter validation, and execution context management, allowing agents to invoke tools with automatic error handling and result serialization back into the agent's reasoning loop.

Phidata provides a unified LLM interface that abstracts over multiple language model providers (OpenAI, Anthropic, Ollama, Groq, local models) through a common API. Developers specify the LLM provider via configuration, and the framework handles provider-specific API calls, token counting, streaming, and response parsing, allowing agents to switch between models without code changes.

Phidata implements conversation memory through a Session abstraction that persists messages, metadata, and user context across multiple backends (file-based JSON, SQLite, PostgreSQL, vector databases). The framework automatically manages session lifecycle, message ordering, and context window management, allowing agents to maintain coherent multi-turn conversations with optional semantic search over historical messages.

Phidata enables agents to extract structured data from unstructured text by defining Pydantic schemas that the LLM uses as output constraints. The framework leverages LLM function calling or structured output modes to ensure responses conform to the schema, with automatic validation and error handling that re-prompts the model if validation fails.

Phidata provides a WebSearch tool that agents can use to query the internet and retrieve current information, integrating with search APIs (DuckDuckGo, Google Search) to fetch and parse web results. The framework automatically formats search results into agent-readable context and handles pagination, deduplication, and result ranking.

Phidata provides utilities to ingest documents (PDFs, text files, markdown) into a knowledge base by chunking them into semantic segments, embedding each chunk, and storing them in a vector database. The framework handles document parsing, metadata extraction, and deduplication, enabling agents to retrieve relevant document segments during reasoning.

Phidata enables agents to break down complex tasks into subtasks through a planning capability where agents use chain-of-thought reasoning to decompose goals, create execution plans, and track progress. The framework supports multi-step reasoning with intermediate checkpoints, allowing agents to validate progress and adjust plans based on tool execution results.

Phidata provides response formatting capabilities that allow developers to define templates for agent outputs, controlling how results are presented to users. The framework supports markdown formatting, structured output templates, and custom formatters that transform raw agent responses into user-friendly formats.