Memory System

Memory System

Prisma Setup

Liz uses Prisma as its ORM, supporting both SQLite and PostgreSQL databases. The schema defines the structure for storing memories and tweets.

// prisma/schema.prisma
datasource db {
  provider = "sqlite" // or "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

model Memory {
  id          String   @id @default(uuid())
  userId      String
  agentId     String
  roomId      String
  content     String   // Stores JSON as string
  type        String
  generator   String   // "llm" or "external"
  createdAt   DateTime @default(now())

  @@index([roomId])
  @@index([userId, agentId])
  @@index([type])
}

model Tweet {
  id             String    @id
  text           String
  userId         String
  username       String
  conversationId String?
  inReplyToId    String?
  createdAt      DateTime  @default(now())
  permanentUrl   String?

  @@index([userId])
  @@index([conversationId])
}

Loading Memories

The loadMemories middleware retrieves relevant conversation history for each request:

// src/middleware/load-memories.ts
export function createLoadMemoriesMiddleware(
	options: LoadMemoriesOptions = {}
): AgentMiddleware {
	const { limit = 100 } = options;

	return async (req, res, next) => {
		const memories = await prisma.memory.findMany({
			where: {
				userId: req.input.userId,
			},
			orderBy: {
				createdAt: "desc",
			},
			take: limit,
		});

		req.memories = memories.map((memory) => ({
			id: memory.id,
			userId: memory.userId,
			agentId: memory.agentId,
			roomId: memory.roomId,
			type: memory.type,
			createdAt: memory.createdAt,
			generator: memory.generator,
			content: JSON.parse(memory.content),
		}));

		await next();
	};
}

Creating Memories

The createMemoryFromInput middleware stores new interactions in the database:

// src/middleware/create-memory.ts
export const createMemoryFromInput: AgentMiddleware = async (
	req,
	res,
	next
) => {
	await prisma.memory.create({
		data: {
			userId: req.input.userId,
			agentId: req.input.agentId,
			roomId: req.input.roomId,
			type: req.input.type,
			generator: "external",
			content: JSON.stringify(req.input),
		},
	});

	await next();
};

// Creating LLM response memories
await prisma.memory.create({
	data: {
		userId: req.input.userId,
		agentId: req.input.agentId,
		roomId: req.input.roomId,
		type: "agent",
		generator: "llm",
		content: JSON.stringify({ text: response }),
	},
});

Memory Context

The wrapContext middleware formats memories into a structured context for LLM interactions:

// src/middleware/wrap-context.ts
function formatMemories(memories: Memory[]): string {
  return memories
    .reverse()
    .map((memory) => {
      const content = memory.content;
      if (memory.generator === "external") {
        return `[${memory.createdAt}] User ${memory.userId}: ${content.text}`;
      } else if (memory.generator === "llm") {
        return `[${memory.createdAt}] You: ${content.text}`;
      }
    })
    .join("\n\n");
}

// Final context structure
<PREVIOUS_CONVERSATION>
${memories}
</PREVIOUS_CONVERSATION>

<AGENT_CONTEXT>
${agentContext}
</AGENT_CONTEXT>

<CURRENT_USER_INPUT>
${currentInput}
</CURRENT_USER_INPUT>

Performance Considerations

Memory Limits

• Default limit of 100 recent memories

• Configurable through middleware options

• Consider token limits of your LLM

• Use indexes for faster queries

Database Tips

• SQLite for development/small apps

• PostgreSQL for production/scale

• Regular database maintenance

• Monitor memory table growth

Next: LLM Integration →