LlamaIndex
Give a LlamaIndex agent a memory of each of your users. A memory block brings what is known about the user into the agent's memory before it answers, or a recall tool lets the agent look things up itself; either way, what happened is saved after the run.
With the package
llama-index-memory-geniffy is a memory block, ready made. Before the agent answers, LlamaIndex puts the user's
briefing in the system message: where things stand, what is due, the rules that apply, what
happened, and what is known that bears on their message. After the run, save() keeps it, tool calls included, in
one memory for the whole conversation.
pip install llama-index-core llama-index-llms-anthropic llama-index-memory-geniffyuv add llama-index-core llama-index-llms-anthropic llama-index-memory-geniffyfrom llama_index.core.agent.workflow import FunctionAgent
from llama_index.core.memory import Memory
from llama_index.llms.anthropic import Anthropic
from llama_index.memory.geniffy import GeniffyMemoryBlock
agent = FunctionAgent(llm=Anthropic(model="claude-opus-5-5"),
system_prompt="You are a helpful assistant.")
async def chat(user_id: str, chat_id: str, message: str) -> str:
block = GeniffyMemoryBlock(space=f"user_{user_id}")
memory = Memory.from_defaults(session_id=chat_id, memory_blocks=[block])
reply = await agent.run(user_msg=message, memory=memory)
await block.save(memory)
return str(reply)The Memory's session_id is the conversation, and each save sends only the run that just finished. In a run with
tools, Geniffy is asked once, not once per step, and if it can't be reached, the agent goes on without memory.
project= keeps the briefing to one project. geniffy_tools(space=...) gives the agent recall and remember
instead. The package is open source:
Geniffy/llama-index-memory-geniffy.
The rest of this page builds a simpler version with the geniffy SDK itself, for when you want to place the
memory yourself: what bears on each message, and each exchange saved.
Install
pip install llama-index-core llama-index-llms-anthropic geniffyuv add llama-index-core llama-index-llms-anthropic geniffySet ANTHROPIC_API_KEY, and GENIFFY_API_KEY from API keys in the Geniffy app. Any LLM LlamaIndex
supports works the same way. These examples use AsyncGeniffy, the same client with every method awaited.
Remember each user
from geniffy import AsyncGeniffy
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.core.llms import ChatMessage
from llama_index.core.memory import BaseMemoryBlock, Memory
from llama_index.llms.anthropic import Anthropic
geniffy = AsyncGeniffy() # reads GENIFFY_API_KEY
agent = FunctionAgent(llm=Anthropic(model="claude-opus-5-5"),
system_prompt="You are a helpful assistant.")
class GeniffyBlock(BaseMemoryBlock[str]):
"""What is known about one of your users that bears on their latest message."""
name: str = "geniffy"
user_id: str
async def _aget(self, messages: list[ChatMessage] | None = None, **kwargs) -> str:
asked = next(m for m in reversed(messages or []) if m.role == "user")
return await geniffy.space(f"user_{self.user_id}").context(asked.content or "")
async def _aput(self, messages: list[ChatMessage]) -> None:
pass # every exchange is saved after the run instead
async def chat(user_id: str, message: str) -> str:
memory = Memory.from_defaults(
session_id=f"user_{user_id}", memory_blocks=[GeniffyBlock(user_id=user_id)],
)
reply = str(await agent.run(user_msg=message, memory=memory))
await geniffy.space(f"user_{user_id}").memories.add(messages=[
{"role": "user", "content": message},
{"role": "assistant", "content": reply},
])
return replyCall it with the user from your own sign-in:
reply = await chat(user.id, "Who signs the Lumen renewal?")LlamaIndex puts the block into the system message, so the agent sees what is known about this user, each line with where it came from. When nothing is known, the block says so in one sentence, so the agent says it doesn't know instead of guessing. The block saves nothing itself: LlamaIndex only hands a block the messages that overflow its short-term memory, and the exchange should reach Geniffy every time.
Let the agent look things up
To let the agent decide when to look something up, give it a recall tool bound to the user. The model
never sees or chooses whose memory it reads.
from geniffy import AsyncGeniffy
from llama_index.core.agent.workflow import FunctionAgent
from llama_index.llms.anthropic import Anthropic
geniffy = AsyncGeniffy()
llm = Anthropic(model="claude-opus-5-5")
INSTRUCTIONS = ("You are a helpful assistant. Use recall before answering anything "
"that depends on what the user said before.")
def agent_for(user_id: str) -> FunctionAgent:
mem = geniffy.space(f"user_{user_id}")
async def recall(query: str) -> str:
"""Look up what is known about the user, with where it came from."""
return await mem.context(query)
return FunctionAgent(llm=llm, tools=[recall], system_prompt=INSTRUCTIONS)
async def chat(user_id: str, message: str) -> str:
reply = str(await agent_for(user_id).run(user_msg=message))
await geniffy.space(f"user_{user_id}").memories.add(messages=[
{"role": "user", "content": message},
{"role": "assistant", "content": reply},
])
return replyThe tool answers with context(), so the agent reads the same lines, with their sources, that the memory
block would hold, and the same sentence when nothing is known.