Phidata: Agent Memory and Planning for Long‑Running Tasks

What Phidata Is and Who It’s For

Phidata is an open‑source Python framework that equips LLM‑based agents with persistent memory and a pluggable planner. It targets developers who need agents to run multi‑step workflows that span hours or days, such as data‑pipeline monitoring, automated research, or continuous code review. Unlike pure chat‑bot libraries, Phidata treats memory as a first‑class store that can be queried, updated, and pruned, while the planner turns a high‑level goal into an executable sequence of tool calls.

Core Features

• Persistent vector memory – integrates with FAISS, Chroma, or Pinecone via a simple Memory API; each interaction is embedded and stored for later retrieval.
• Goal‑driven planner – accepts a natural‑language objective, decomposes it into sub‑tasks, and selects appropriate tools from a registry.
• Tool abstraction – any Python function or external API can be wrapped as a Tool; the agent can call them synchronously or asynchronously.
• State checkpointing – agents can serialize their internal state (memory index, planner progress) to disk and resume later.
• Observability hooks – built‑in logging of token usage, tool calls, and memory hits, exportable to JSON or Prometheus.

Architecture Overview

At its core, a Phidata Agent composes three modules:

1. LLM Engine – any model compatible with LiteLLM (OpenAI, Anthropic, local HuggingFace) provides the reasoning loop.
2. Memory Store – a wrapper around a vector database; the add method stores embeddings of user messages, tool outputs, or intermediate notes; the query method returns the top‑k most relevant snippets.
3. Planner – a rule‑based or LLM‑driven module that, given a goal and the current memory context, outputs a JSON plan: [{ "tool": "web_search", "args": {"q": "latest Phidata release"}, "next_if": "success" }]. The executor iterates over the plan, updating memory after each step.

Data flow: user prompt → planner → tool execution → result stored in memory → LLM receives updated context → next planning cycle.

Real‑World Use Cases

• Automated literature review: an agent receives a research question, queries arXiv via a Tool, stores each paper’s abstract in memory, and iteratively refines queries until coverage thresholds are met.
• Continuous code quality monitoring: the agent runs a linter, stores violations in memory, compares against a baseline, and opens a pull request when new issues exceed a limit.
• Personal assistant for long trips: the agent keeps a running itinerary, updates it with flight changes stored in memory, and suggests activities based on location and time remaining.

Strengths and Limitations

Strengths

• Memory persistence is decoupled from the LLM, allowing agents to survive process restarts.
• Planner is interchangeable; you can swap a simple rule‑based planner for a more sophisticated LLM‑planner without changing agent code.
• Minimal boilerplate: a functional agent can be instantiated in under 15 lines of code.

Limitations

• The default planner relies on the LLM’s ability to produce valid JSON; malformed outputs can break the execution loop, requiring additional validation layers.
• Vector‑store integration adds an external dependency; for very short tasks the overhead may outweigh benefits.
• Community size is smaller than LangChain or LlamaIndex, so fewer third‑party tool wrappers are available today.

Comparison with Alternatives

Feature	Phidata	LangChain/LangGraph	LlamaIndex
Persistent memory	Vector store API	Requires custom implementation	Built‑in index
Planner flexibility	Pluggable (rule/LLM)	Graph‑based workflow	Query‑engine focus
Tool abstraction	Simple wrapper	AgentToolkit	Limited
Checkpoint/resume	Built‑in state dump	External saver needed	Not native
Community & docs	Growing, ~2k stars	Large, extensive	Moderate

Stars approximated from GitHub as of September 2025.

Getting Started

1. Install the package:

   pip install phidata
   

2. Create a minimal agent that remembers user preferences:

   from phidata import Agent, Memory, Tool
   from phidata.tools import DuckDuckGoSearch
   
   # 1️⃣ Memory – using FAISS locally
   mem = Memory(index_type="faiss", persist_path="./agent_mem")
   
   # 2️⃣ Tool – web search
   search_tool = Tool(name="web_search", func=DuckDuckGoSearch().run)
   
   # 3️⃣ Agent – ties LLM, memory, and tools together
   agent = Agent(
       llm_model="gpt-4o-mini",
       memory=mem,
       tools=[search_tool],
       planner_type="llm",  # uses the LLM to generate JSON plans
   )
   
   # 4️⃣ Run a goal
   result = agent.run(
       goal="Find the latest Phidata release notes and summarize them."
   )
   print(result)
   

   The agent will:
   • Query the planner for a plan to satisfy the goal.
   • Execute web_search, store the result in memory.
   • Ask the LLM to produce a summary using the retrieved snippets.
   • Persist the memory index to ./agent_mem for future runs.

Further Reading

• Official GitHub repository: https://github.com/phidata/phidata
• Documentation (quick start guide): https://phidata.readthedocs.io/en/latest/
• Blog post on long‑term memory patterns: https://phidata.io/blog/memory-patterns