Framework Integrations

SenseLab integrates with popular agent frameworks so you can add persistent memory to your existing workflows. Every integration is a thin wrapper around one AgentMemory instance: you build the memory, connect it to your account, and hand it to the wrapper.

Setup

Install the SDK and the HTTP adapter, then build one connected memory that every integration below shares:

pip install amfs amfs-adapter-http
export AMFS_API_KEY="<your-api-key>"

import os

from amfs import AgentMemory
from amfs_adapter_http import HttpAdapter

mem = AgentMemory(
    agent_id="research-agent",
    adapter=HttpAdapter(
        base_url="https://amfs-login.sense-lab.ai",
        api_key=os.environ["AMFS_API_KEY"],
    ),
)

The integrations do not read AMFS_HTTP_URL or AMFS_API_KEY, and neither does AgentMemory. A memory created without adapter= stores everything in .amfs/ on the local disk — silently — and nothing reaches your dashboard. Pass the HttpAdapter as above.

Each package has an extra that pulls in the framework itself, for example pip install "amfs-crewai[crewai]". If you already have the framework installed, the plain package is enough. Get a key from the Connect to SenseLab guide.

CrewAI

Add SenseLab tools to your CrewAI agents:

pip install amfs-crewai

from crewai import Agent
from amfs_crewai import AMFSTool

tools = AMFSTool(mem).tools()
# [amfs_read, amfs_write, amfs_list] — CrewAI BaseTool instances

agent = Agent(
    role="Researcher",
    goal="Analyze the codebase",
    tools=tools,
)

The tools let a CrewAI agent read an entry (entity_path, key), write one (entity_path, key, JSON value) and list entries as part of its task. Requires CrewAI 0.80 or later; tools() raises ImportError with the install hint if CrewAI is missing.

LangGraph

Keep graph state in SenseLab, keyed by thread_id:

pip install amfs-langgraph

from amfs_langgraph import AMFSCheckpointer

checkpointer = AMFSCheckpointer(mem)                       # entity_path="_langgraph_checkpoints"

config = {"configurable": {"thread_id": "conv-123"}}
checkpointer.put(config, {"messages": [...], "step": 3})   # new version on every put
latest = checkpointer.get(config)                          # the latest checkpoint, or None
all_versions = checkpointer.list(config)                   # every version for the thread

Because every put is a new version of the same entry, a thread’s full history is kept and list returns it.

AMFSCheckpointer is a minimal checkpoint store with put, get and list. It does not implement LangGraph’s BaseCheckpointSaver interface, so call it from your own nodes or wrap it rather than passing it straight to graph.compile(checkpointer=...).

LangChain

Use SenseLab as chat memory for LangChain:

pip install amfs-langchain

from amfs_langchain import AMFSChatMemory

chat_memory = AMFSChatMemory(mem, session_key="conv-123")  # entity_path="_langchain_chat"

# Save a turn
chat_memory.save_context(
    {"input": "What's the retry policy?"},
    {"output": "We use exponential backoff with max 3 retries."},
)

# Load the conversation
history = chat_memory.load_memory_variables({})
# {"history": [{"input": "...", "output": "..."}, ...]}

chat_memory.clear()

Each session is one entry, versioned on every turn, so mem.history("_langchain_chat", "conv-123") shows how the conversation grew.

AutoGen

Use SenseLab as a key-value memory store for AutoGen agents:

pip install amfs-autogen

from amfs_autogen import AMFSMemoryStore

store = AMFSMemoryStore(mem)          # entity_path="_autogen_memory"

store.add("user_prefs", {"theme": "dark"})
prefs = store.get("user_prefs")       # {"theme": "dark"}
everything = store.get_all()          # {key: value, ...}
store.clear("user_prefs")             # writes None at confidence 0.0; history is kept

Strands Agents

Add memory to a Strands agent as a plugin:

pip install amfs-strands

from strands import Agent
from amfs_strands import AMFSPlugin

agent = Agent(
    system_prompt="You are a research assistant with persistent memory.",
    plugins=[AMFSPlugin(mem)],
)

agent("Research the latest AI papers and remember key findings")

The plugin registers six tools — amfs_read, amfs_write, amfs_search, amfs_recall, amfs_list and amfs_record_context — and also records the agent’s other tool calls into the causal chain as contexts, so the decision trace covers the whole session rather than only the memory operations. Pass AMFSPlugin(mem, auto_trace=False) to register the tools without that tracing. Requires strands-agents 1.0 or later. If you’d rather have one action-based tool than the full plugin, amfs_memory handles store, retrieve, search and list:

from strands import Agent
from amfs_strands import amfs_memory

agent = Agent(tools=[amfs_memory])

amfs_memory builds its own AgentMemory — identity from AMFS_AGENT_ID (default strands-agent), storage from amfs.yaml or the local .amfs/ directory — so it does not reach SenseLab. Use AMFSPlugin with the connected memory from Setup for that.

Close the loop

The wrappers above read and write. What makes the memory improve is telling SenseLab how the task went, on the same mem the framework used: every entry the agent read during the run is already in its read log.

from amfs import OutcomeType

# ... the crew / graph / agent runs ...

mem.commit_outcome(
    "task-42", OutcomeType.SUCCESS,
    task_input="research the latest AI papers",
    response_text=final_answer,
)

Entries that led to a success gain confidence; entries that led to a failure lose it, and the next run’s reads and briefing reflect that. See Outcomes and decision traces in the Python SDK guide.

Building your own integration

All integrations are thin wrappers around the AgentMemory API. To build your own:

Accept an AgentMemory instance in your constructor
Map your framework’s memory/tool API to mem.read(), mem.write(), mem.list(), mem.search()
Use entity_path to scope data (per conversation, per task, per agent)

class MyFrameworkMemory:
    def __init__(self, mem: AgentMemory, scope: str = "default"):
        self._mem = mem
        self._scope = scope

    def save(self, key: str, data: dict):
        self._mem.write(self._scope, key, data)

    def load(self, key: str):
        entry = self._mem.read(self._scope, key)
        return entry.value if entry else None

Agents working through an MCP client (Cursor, Claude Code, Codex) need none of this — see the MCP server guide.

What’s next

Python SDK

The full AgentMemory API that every integration wraps.

Core Concepts

Understand versioning, provenance, and causal graphs in SenseLab.

Product

Getting Started

Guides

Self-Hosting

Core Concepts

Pro Features

Framework Integrations

Setup

CrewAI

LangGraph

LangChain

AutoGen

Strands Agents

Close the loop

Building your own integration

What’s next

Python SDK

Core Concepts

​Setup

​CrewAI

​LangGraph

​LangChain

​AutoGen

​Strands Agents

​Close the loop

​Building your own integration

​What’s next

Python SDK

Core Concepts

Setup

CrewAI

LangGraph

LangChain

AutoGen

Strands Agents

Close the loop

Building your own integration

What’s next