Guides / Frameworks

CrewAI

For CrewAI developers whose crews work for people: travellers, customers, students. crewai-recall puts what Recall knows about the person into the task and gives agents tools to look things up and save what they learn.

What memory adds

	Without memory	With Recall
A request from a returning traveller	The crew asks again about diet, budget and flight times.	The task starts with the traveller's peer card and the facts that relate to the request.
"I hate early flights," mentioned once	Gone after the kickoff.	Saved by an agent with `recall_remember`, or learned from the recorded request.
"What did we book in Porto last spring?"	Nobody knows.	`recall_ask` answers from earlier conversations.

Recall is memory, not the crew: CrewAI still plans, delegates and runs the tools.

How it maps onto Recall

In CrewAI	In Recall	Why
Your app	Workspace, from `RECALL_WORKSPACE_ID`	Memory stays inside it.
The person the crew works for	Peer `user-8412`	Recall learns about this person; the tools read and write their memory.
The crew	Peer `travel-crew`, not learned about	Its answers are stored as context; facts are learned about the person.
A request and its answer	Session, e.g. `trip-lisbon`	What Recall learns from, in order.

Build it

Install the package with pip install crewai-recall and set RECALL_API_KEY (create one at app.recallmem.dev/keys), or RECALL_URL for a server of your own.

Agents with memory tools. recall_tools(user_id) gives an agent recall_search, recall_ask and recall_remember for one person. A {memory} placeholder in the task takes what Recall knows.

from crewai import Agent, Crew, Task
from crewai_recall import recall_context, recall_tools
from recall_memory import PeerConfig, Recall

recall = Recall(workspace_id="travel-crew")

# The crew works for one traveller per run: their id is the Recall peer. `llm` is your
# CrewAI LLM; None uses CrewAI's default.
traveller = "user-8412"
concierge = Agent(
    role="Travel concierge",
    goal="Plan trips the traveller will love",
    backstory="You remember what each traveller likes and never ask twice.",
    tools=recall_tools(traveller, client=recall),
    llm=llm,
)
plan = Task(
    description="{request}\n\nWhat you know about the traveller:\n{memory}",
    expected_output="A day-by-day plan",
    agent=concierge,
)
crew = Crew(agents=[concierge], tasks=[plan])

Each kickoff. recall_context reads the person's card and the facts that relate to the request, with no model call, and goes in with the inputs.

# Memory goes in with the inputs: the card and the facts that relate to this request.
request = "I'm vegetarian and I hate early flights. Plan a weekend in Lisbon."
memory = recall_context(traveller, query=request, client=recall)
result = crew.kickoff(inputs={"request": request, "memory": memory})

Record the conversation. Recall learns from conversations, so store the request and the crew's answer with the SDK:

# Recall learns from conversations: store the request and the crew's answer. The crew is a
# peer Recall does not learn about.
person = recall.peer(traveller)
crew_peer = recall.peer("travel-crew", configuration=PeerConfig(observe_me=False))
recall.session("trip-lisbon").add_messages(
    [person.message(request), crew_peer.message(str(result))]
)

CrewAI's own memory

CrewAI's Memory accepts a custom storage backend, but that interface is a vector store: CrewAI computes the embeddings and the backend stores and searches vectors. Recall learns from text and searches it itself, so it is offered as tools and task context instead. You can leave CrewAI's memory on for what agents learn while working; Recall keeps what matters about the people they work for, across crews and apps.

Settings that matter

Setting	Use
`recall_tools(user_id, ...)`	One set of tools per person. Build them per kickoff when one crew definition serves many people.
`recall_context(query=...)`	The request, so the facts that matter for it come first. Without it you get the most frequent facts.
`max_conclusions`	Most facts in the context (20 by default).
`k`, `reasoning_level`	Results per search, and how hard `recall_ask` thinks: `low` by default. See Reasoning levels and models.

Cost and speed

recall_context is a context read with no model call: context reads took 0.3 to 0.7 seconds, measured from Europe against the hosted API (Frankfurt), October 2026, small next to a crew's own model calls. recall_search searches facts and messages without a model call, in about a second. recall_ask is one model call of 2 to 4.5 seconds at low. Learning from recorded conversations runs in the background.

Context, search and storage are included. Learning and questions are charged; see pricing and Cost and speed for worked examples.

Privacy and forgetting

The tools send queries, questions and the facts an agent saves to Recall; what you record is up to you. Record the person's request and the crew's answer, not tool output or intermediate steps. To forget someone:

# The traveller deletes their account: erase them, then the trips that hold the answers.
trips = list(person.sessions())
person.delete()
for trip in trips:
    trip.delete()

See Forget a person and Privacy, consent and forgetting.

Pitfalls

One set of tools for everyone. Tools are bound to one person. Reusing them across people mixes memories; build them per kickoff.
Never recording. Tools and context only read and save facts. Recall learns from conversations you store.
Agents saving guesses. Tell agents to save what the person stated, not their own conclusions about them.

Next: Multi-agent systems · Designing workspaces, peers and sessions