Anvia Docs

Use Prisma when your application already stores conversation data through a Prisma client. The key is to store each Anvia Message as JSON and load messages in insertion order.

Prisma Schema

model AgentMemoryMessage {
  id        BigInt   @id @default(autoincrement())
  sessionId String
  userId    String?
  runId     String
  turn      Int
  message   Json
  metadata  Json?
  createdAt DateTime @default(now())

  @@index([sessionId, id])
}

model AgentMemoryError {
  id        BigInt   @id @default(autoincrement())
  sessionId String
  userId    String?
  runId     String
  error     Json
  messages  Json
  createdAt DateTime @default(now())

  @@index([sessionId, createdAt])
}

Store

import type {
  MemoryAppendInput,
  MemoryContext,
  MemoryErrorInput,
  MemoryStore,
  Message,
} from "@anvia/core";
import { Prisma, PrismaClient } from "@prisma/client";

export class PrismaMemoryStore implements MemoryStore {
  constructor(private readonly prisma: PrismaClient) {}

  async load(context: MemoryContext): Promise<Message[]> {
    const rows = await this.prisma.agentMemoryMessage.findMany({
      where: { sessionId: context.sessionId },
      orderBy: { id: "asc" },
      select: { message: true },
    });

    return rows.map((row) => row.message as unknown as Message);
  }

  async append(input: MemoryAppendInput): Promise<void> {
    await this.prisma.agentMemoryMessage.createMany({
      data: input.messages.map((message) => ({
        sessionId: input.context.sessionId,
        userId: input.context.userId,
        runId: input.runId,
        turn: input.turn,
        message: toPrismaJson(message),
        metadata:
          input.context.metadata === undefined
            ? undefined
            : toPrismaJson(input.context.metadata),
      })),
    });
  }

  async clear(context: MemoryContext): Promise<void> {
    await this.prisma.agentMemoryMessage.deleteMany({
      where: { sessionId: context.sessionId },
    });
  }

  async recordError(input: MemoryErrorInput): Promise<void> {
    await this.prisma.agentMemoryError.create({
      data: {
        sessionId: input.context.sessionId,
        userId: input.context.userId,
        runId: input.runId,
        error: toPrismaJson(serializeError(input.error)),
        messages: toPrismaJson(input.messages),
      },
    });
  }
}

function toPrismaJson(value: unknown): Prisma.InputJsonValue {
  return JSON.parse(JSON.stringify(value)) as Prisma.InputJsonValue;
}

function serializeError(error: unknown): Record<string, unknown> {
  if (error instanceof Error) {
    return {
      name: error.name,
      message: error.message,
      stack: error.stack,
    };
  }
  return { message: String(error) };
}

Use It

const prisma = new PrismaClient();
const memory = new PrismaMemoryStore(prisma);

const agent = new AgentBuilder("support", model)
  .memory(memory, { savePolicy: "message" })
  .build();

await agent.session("thread_123", { userId: "user_456" }).prompt("Hello").send();