Total Recall: ControlFlow v0.10

I’m really excited about the release of ControlFlow v0.10, which introduces a significant new feature: a flexible and practical memory system for AI agents.

Here’s an example that shows how simple it is to get started:

import controlflow as cf

memory = cf.Memory(key="prefs", instructions="Remember user preferences.")

cf.run(
    "Get the user's favorite color",
    interactive=True,
    memories=[memory],
)

Memory addresses a key limitation in many AI workflows: the inability to leverage knowledge and context beyond the current interaction. Now your agents can:

• Recall configuration and project details: Agents remember settings, project structures, and workflows, ensuring consistency across tasks without repeated setup.

• Track ongoing issues and resolutions: Keep a log of common problems and their solutions, enabling agents to offer quick fixes for recurring issues.

• Integrate past conversations and decisions: Retain key insights and decisions from previous discussions, informing future tasks without rehashing old ground.

• Maintain technical styles and best practices: Agents adapt to coding styles, design patterns, and best practices, applying them consistently across workflows.

• Store repository knowledge and code locations: Agents remember where key components or documentation live, speeding up development and debugging.

• Optimize API usage: Recall specific API tips, tricks, and edge cases, providing more efficient solutions beyond the standard documentation.

• Summarize long-term project insights: Capture key learnings from long-running projects, enabling agents to seamlessly continue tasks without re-creating context.

An emergent characterization of production AI workflows is that they tend to be short, directed, and scaled across many concurrent agents. In other words, effective memory systems shouldn’t optimize for summarizing the longest possible conversation (as this is straightforward within any single session), but for rapidly establishing the context that ensures consistent behavior across many invocations.

ControlFlow’s solution is a modular, vector-backed memory system that not only allows you to store and retrieve information, but lets you quickly provide access to various memories on a per-task or per-agent basis.

Getting Started with Memory

Suppose we want to store user preferences, but we need to make sure that Alice’s preferences don’t get mixed up with Bob’s. To achieve this, we can give each user their own dedicated memory module. Here’s a flow that demonstrates how to do it:

import controlflow as cf


@cf.flow
def demo(user_id: str):
    # create a memory module for the user
    memory = cf.Memory(
        key=f"{user_id}_prefs",
        instructions="Remember user preferences about writing.",
    )

    # use the memory module in the task
    return cf.run(
        "Write a poem on a topic of the user's choice",
        instructions="Share drafts with the user until they are happy.",
        interactive=True,
        memories=[memory],
    )


# run the flow for Alice and Bob, without mixing up their memories
demo("Alice")
demo("Bob")

Later, Alice and Bob might be part of the same conversation, and we could provide both of their memory modules to the agent at the same time!

To start using the new memory feature, upgrade to ControlFlow 0.10 and install your preferred vector store (ControlFlow currently supports Chroma and LanceDB).

pip install --upgrade controlflow

For more information on integrating memory into your workflows, please refer to the updated documentation.

Happy AI engineering!