GeniffyDocs
Changelog Log In Get a key

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.

Terminal
pip install llama-index-core llama-index-llms-anthropic llama-index-memory-geniffy

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

Terminal
pip install llama-index-core llama-index-llms-anthropic geniffy

Set 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

agent.py
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 reply

Call 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.

agent.py
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 reply

The 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.

Last updated October 9, 2026