Your AI agent
    |
    |--- AI SDK adapter (import "code-memory/adapter")
    |         |
    |         |-- memoryTools       injected into generateText/streamText
    |         |-- memoryMiddleware  auto recall + auto store via wrapLanguageModel
    |         |-- MemoryEmbeddingModel  AI SDK-compatible EmbeddingModelV3
    |
    |--- MCP stdio server (bun run start)
    |         |
    |         | stdio (JSON-RPC)
    |
    |--- Embedding Backend (ollama / openai)
    |
    |--- SQLite
           |-- session
           |-- memory (content + embedding blob)
           |-- memory_edge (similarity links)

bun add memkit ai
# or
npm install memkit ai

import { createMemory } from "memkit/adapter"
import { streamText, stepCountIs } from "ai"
import { openai } from "@ai-sdk/openai"

const memory = createMemory({
  projectId: "my-app",
  sessionId: "user-abc",
})

// Wrap your model — auto recall before generation, auto store after
const model = memory.wrapModel(openai("gpt-4o"))

const result = await streamText({
  model,
  tools: { ...memory.tools },
  stopWhen: stepCountIs(10),
  messages,
})

import { wrapLanguageModel, streamText } from "ai"
import { memoryMiddleware } from "memkit/adapter"
import { anthropic } from "@ai-sdk/anthropic"

const model = wrapLanguageModel({
  model: anthropic("claude-sonnet-4-5"),
  middleware: memoryMiddleware({
    projectId: "my-app",
    sessionId: "user-abc",
    searchOptions: {
      limit: 5,         // top memories to inject (default: 5)
      minScore: 0.55,   // similarity threshold (default: 0.55)
      expandGraph: true // pull in graph neighbors (default: false)
    },
    autoRecall: true,   // inject memories before generation (default: true)
    autoStore: true,    // store assistant replies after generation (default: true)
    // optional: customize the memory block injected into the system prompt
    systemPromptTemplate: (memories) =>
      `<memory>\n${memories.map(m => m.content).join("\n")}\n</memory>`,
  }),
})

const result = await streamText({ model, messages })

import { generateText, stepCountIs } from "ai"
import { memoryTools } from "memkit/adapter"
import { openai } from "@ai-sdk/openai"

const result = await generateText({
  model: openai("gpt-4o"),
  tools: { ...memoryTools },
  stopWhen: stepCountIs(10),
  system: `You have persistent memory. Use add_memory to store important context.
Use search_memory before answering questions that might benefit from past context.`,
  messages,
})

import { createMemoryAsync } from "memkit/adapter"
import { embed } from "ai"

const memory = await createMemoryAsync({
  projectId: "my-app",
  sessionId: "user-abc",
})

// memory.embeddingModel is a fully typed EmbeddingModelV3
const { embedding } = await embed({
  model: memory.embeddingModel,
  value: "some text to embed",
})

{
  projectId: string
  sessionId: string
  searchOptions?: {
    limit?: number       // default 5
    minScore?: number    // default 0.55
    expandGraph?: boolean // default false
  }
  autoStore?: boolean    // default true
  autoRecall?: boolean   // default true
  systemPromptTemplate?: (memories: SearchResult[]) => string
}

curl -fsSL https://ollama.ai/install.sh | sh
ollama pull nomic-embed-text

git clone https://github.com/xmanish/memkit.git
cd memkit
bun install
bun run start

{
  "mcpServers": {
    "memory": {
      "command": "bun",
      "args": ["run", "/path/to/memkit/src/server.ts"],
      "env": {
        "EMBEDDING_BACKEND": "ollama"
      }
    }
  }
}

{
  "mcp": {
    "memory": {
      "type": "stdio",
      "command": "bun",
      "args": ["run", "/path/to/code-memory/src/server.ts"],
      "env": {
        "EMBEDDING_BACKEND": "ollama"
      }
    }
  }
}

import { streamText, experimental_createMCPClient } from "ai"

const mcp = await experimental_createMCPClient({
  transport: {
    type: "stdio",
    command: "bun",
    args: ["run", "/path/to/code-memory/src/server.ts"],
  },
})

const tools = await mcp.tools()

const result = await streamText({
  model: "anthropic/claude-sonnet-4-5",
  tools,
  messages,
  system: `You have persistent memory. Use add_memory to store important context.
Use search_memory before answering questions that benefit from past context.`,
})

# embedding backend: "ollama" (default) or "openai"
EMBEDDING_BACKEND=ollama

# ollama
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_EMBED_MODEL=nomic-embed-text

# openai (only needed if EMBEDDING_BACKEND=openai)
OPENAI_API_KEY=sk-...
OPENAI_EMBED_MODEL=text-embedding-3-small

# database location
DB_PATH=~/.memkit/memory.db

# graph linking
EDGE_THRESHOLD=0.82
EDGE_TOP_K=10

{
  "content": "The user prefers dark mode and uses vim keybindings",
  "session_id": "sess_abc123",
  "project_id": "proj_myapp",
  "metadata": { "source": "user_preference" }
}

{
  "query": "what editor settings does the user like",
  "project_id": "proj_myapp",
  "limit": 5,
  "min_score": 0.6,
  "expand_graph": true
}

{ "memory_id": "mem_abc123", "depth": 2 }

{ "id": "mem_abc123" }

{ "project_id": "proj_myapp" }

{ "session_id": "sess_abc123" }

"user likes dark mode" ----0.91---- "prefers dark themes in all apps"
                           |
                         0.85
                           |
                  "UI should default to dark"

code-memory/
  src/
    server.ts              MCP stdio server, tool routing
    memory.ts              core logic: add, search, graph traversal
    db.ts                  SQLite setup, migrations, cosine similarity
    types.ts               zod schemas for all inputs and outputs
    embeddings/
      index.ts             backend factory (ollama | openai)
      ollama.ts            ollama embedding client
      openai.ts            openai embedding client
    adapter/               AI SDK integration layer
      index.ts             public exports
      tools.ts             AI SDK tool() definitions
      middleware.ts        LanguageModelMiddleware — auto recall + store
      embedding-model.ts   EmbeddingModelV3 adapter
      create-memory.ts     createMemory() / createMemoryAsync() factories
  package.json
  tsconfig.json
  README.md