Phidata

Provides a unified Python API that abstracts over OpenAI, Anthropic, Google, and local models (via Ollama), normalizing their function-calling schemas and response formats into a common interface. Internally maps provider-specific tool definitions to a canonical schema, handles provider-specific quirks in structured output formatting, and routes calls to the appropriate provider's API with automatic retry and error handling logic.

Implements a pluggable memory architecture that stores agent conversation history, tool execution results, and reasoning traces across sessions. Uses a message-based storage model where each interaction (user input, agent response, tool calls) is persisted as a structured record, with support for multiple backends (in-memory, SQLite, PostgreSQL) and automatic context window management to fit within model token limits.

Supports streaming LLM responses and tool results back to clients incrementally, rather than waiting for complete responses, enabling real-time feedback and lower perceived latency. Implements streaming at multiple levels: token-level streaming from the LLM, tool-result streaming as tools complete, and aggregated streaming that combines both into a unified output stream with proper formatting.

Provides a configuration system that allows agents to be instantiated with different LLM providers, memory backends, tool registries, and other components without code changes, using dependency injection patterns. Supports environment variables, configuration files, and programmatic configuration, with automatic validation and type checking of configuration values.

Implements sophisticated error handling that catches failures at multiple levels (API errors, tool execution errors, validation errors) and applies recovery strategies such as exponential backoff, prompt refinement, or fallback to alternative tools. Distinguishes between recoverable errors (rate limits, transient network issues) and unrecoverable errors (invalid tool calls, schema violations), with configurable retry policies per error type.

Phidata integrates vision models (OpenAI Vision, Claude Vision, etc.) for analyzing images and providing detailed descriptions, object detection, text extraction (OCR), and visual reasoning. The framework handles image encoding, provider-specific vision API calls, and response parsing for vision-enabled agents.

Provides built-in RAG capabilities that allow agents to query external knowledge bases (documents, databases, web) and inject relevant context into prompts before generation. Implements a retrieval pipeline that accepts various document formats, chunks them using configurable strategies, embeds them with provider-agnostic embedding models, stores them in vector databases (Pinecone, Weaviate, local), and retrieves top-k results based on semantic similarity to augment agent context.

Enables agents to generate responses that conform to predefined JSON schemas, using provider-native structured output APIs (OpenAI's JSON mode, Anthropic's tool_use) or fallback parsing strategies. Validates generated outputs against schemas before returning them, with automatic retry logic if validation fails, and provides type hints for Python developers to ensure type safety in downstream code.

Provides a decorator-based system for registering Python functions as agent tools, automatically extracting function signatures, docstrings, and type hints to generate tool schemas compatible with provider APIs. Handles tool invocation by routing function calls from the model back to registered Python functions, managing argument binding, error handling, and result serialization without requiring manual schema definitions.

Enables building teams of specialized agents that communicate via a message-passing architecture, where agents can delegate tasks to other agents, aggregate results, and coordinate on complex problems. Implements a supervisor pattern where a lead agent routes tasks to worker agents based on their capabilities, with automatic message routing, context sharing between agents, and result aggregation without requiring explicit workflow definitions.

Provides built-in support for reasoning patterns like chain-of-thought, step-by-step planning, and self-reflection, where agents can break down problems into intermediate steps, evaluate their own reasoning, and adjust strategies. Implements this via system prompts that encourage reasoning, tool calls that capture intermediate results, and memory that tracks reasoning traces for later analysis or refinement.

Integrates web search capabilities (via DuckDuckGo, Google Search, or similar) as agent tools, allowing agents to query the internet for real-time information and current events. Implements search result parsing, deduplication, and ranking to surface the most relevant results, with automatic result summarization to fit within context windows and caching to avoid redundant searches.

Provides native support for running open-source models locally via Ollama, allowing agents to work completely offline or on-premises without relying on cloud APIs. Handles model downloading, inference, and response parsing for Ollama-compatible models, with the same unified API as cloud providers, enabling seamless switching between local and cloud models.

Provides comprehensive logging and monitoring of agent execution, capturing all LLM calls, tool invocations, memory accesses, and reasoning steps in structured logs. Enables debugging by replaying execution traces, analyzing agent behavior, and identifying failure points, with support for exporting logs to external monitoring systems (e.g., Datadog, CloudWatch) and generating execution summaries.