持久性记忆服务器

┌─────────────────────────────────────────────────┐
│  AI Clients (Claude, ChatGPT, custom agents)    │
│  Connect via MCP JSON-RPC over HTTPS            │
└──────────────────────┬──────────────────────────┘
                       │
         ┌─────────────▼─────────────┐
         │   Supabase Edge Function  │
         │   (Deno runtime)          │
         │                           │
         │  ┌─────────────────────┐  │
         │  │  Auth + Audit Layer │  │
         │  │  (SHA-256 key hash) │  │
         │  └────────┬────────────┘  │
         │           │               │
         │  ┌────────▼────────────┐  │
         │  │  9 MCP Tools        │  │
         │  │  capture, search,   │  │
         │  │  browse, stats,     │  │
         │  │  spark, update,     │  │
         │  │  delete, scorecard, │  │
         │  │  feedback           │  │
         │  └────────┬────────────┘  │
         │           │               │
         └───────────┼───────────────┘
                     │
    ┌────────────────┼────────────────┐
    │                │                │
    ▼                ▼                ▼
┌────────┐   ┌────────────┐   ┌───────────┐
│Supabase│   │ OpenRouter  │   │ Telegram  │
│Postgres│   │ (embeddings │   │ (optional │
│+pgvector│  │  + LLM)     │   │  alerts)  │
└────────┘   └────────────┘   └───────────┘

INSERT INTO agents (name, key_hash, scopes, active)
VALUES (
  'my-first-agent',
  encode(digest('replace-with-your-secret-key', 'sha256'), 'hex'),
  '{"master"}',
  true
);

-- Read-only agent (search and browse only)
INSERT INTO agents (name, key_hash, scopes, active)
VALUES (
  'readonly-agent',
  encode(digest('your-readonly-key', 'sha256'), 'hex'),
  '{"read-only"}',
  true
);

-- Capture-only agent (store memories and give feedback, no delete)
INSERT INTO agents (name, key_hash, scopes, active)
VALUES (
  'capture-agent',
  encode(digest('your-capture-key', 'sha256'), 'hex'),
  '{"capture-only", "feedback"}',
  true
);

git clone https://github.com/YOUR_USERNAME/persistent-mcp-server.git
cd persistent-mcp-server

# Link to your Supabase project
supabase link --project-ref YOUR_PROJECT_REF

# Deploy
supabase functions deploy persistent-mcp --no-verify-jwt

https://YOUR_PROJECT_REF.supabase.co/functions/v1/persistent-mcp

# Health check
curl https://YOUR_PROJECT_REF.supabase.co/functions/v1/persistent-mcp
# Expected: {"status":"online","version":"1.0.0","protocol":"mcp-jsonrpc"}

# Test a capture
curl -X POST \
  "https://YOUR_PROJECT_REF.supabase.co/functions/v1/persistent-mcp?key=your-secret-key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/call",
    "params": {
      "name": "capture_thought",
      "arguments": { "content": "Test memory — server is working!" }
    }
  }'

# Test a search
curl -X POST \
  "https://YOUR_PROJECT_REF.supabase.co/functions/v1/persistent-mcp?key=your-secret-key" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 2,
    "method": "tools/call",
    "params": {
      "name": "search_thoughts",
      "arguments": { "query": "test memory" }
    }
  }'

{
  "mcpServers": {
    "memory": {
      "url": "https://YOUR_PROJECT_REF.supabase.co/functions/v1/persistent-mcp?key=your-secret-key"
    }
  }
}

const PROJECTS: string[] = [
  "default",
  "personal",
  "work",
  "research",
  "infrastructure",
  // Add your own:
  "side-project",
  "health",
  "finances",
];

supabase functions deploy persistent-mcp --no-verify-jwt

const EMBEDDING_MODEL = "openai/text-embedding-3-small";   // Must output 1536-dim vectors
const EXTRACTION_MODEL = "openai/gpt-4o-mini";             // Cheap + fast for metadata
const ANALYSIS_MODEL = "anthropic/claude-haiku-4-5";        // Smarter = better Spark insights
const NARRATIVE_MODEL = "openai/gpt-4o-mini";               // Scorecard personality

ALTER TABLE thoughts ALTER COLUMN embedding TYPE VECTOR(768);
-- Also update the match_thoughts function parameter type

INSERT INTO agents (name, key_hash, scopes, active)
VALUES (
  'custom-agent',
  encode(digest('my-key', 'sha256'), 'hex'),
  '{"capture", "read", "spark"}',
  true
);

DROP INDEX IF EXISTS idx_thoughts_embedding;
CREATE INDEX idx_thoughts_embedding
  ON thoughts USING ivfflat (embedding vector_cosine_ops)
  WITH (lists = 300);  -- target: sqrt(total_rows)

// Example: adding an "urgency" field
const prompt = `Extract metadata. Return ONLY valid JSON.
{
  "type": "observation|decision|action_item|idea",
  "topics": ["topic1"],
  "urgency": "low|medium|high|critical",
  "importance": 5,
  "summary": "one-line summary"
}`;

addTool(
  "my_tool",
  "What this tool does",
  {
    param1: z.string().describe("Description"),
    param2: z.number().optional().describe("Optional param"),
  },
  async ({ param1, param2 }) => {
    // Your logic here
    return {
      content: [{ type: "text", text: `Result: ${param1}` }],
    };
  }
);

my_tool: ["write", "my-custom-scope"],

# macOS (Homebrew)
brew install postgresql@16
brew install pgvector

# Ubuntu/Debian
sudo apt install postgresql postgresql-contrib
# Then install pgvector from source:
git clone https://github.com/pgvector/pgvector.git
cd pgvector && make && sudo make install

createdb mcp_memory
psql mcp_memory < schema.sql

export SUPABASE_URL="http://localhost:54321"  # or your local Postgres connection
export SUPABASE_SERVICE_ROLE_KEY="not-needed-locally"
export OPENROUTER_API_KEY="your-openrouter-key"

# Install Supabase CLI
npm install -g supabase

# Initialize and start local Supabase (includes Postgres + pgvector + API)
supabase init
supabase start

supabase functions serve persistent-mcp --no-verify-jwt --env-file .env

// Replace getSupabase() with:
import postgres from "https://deno.land/x/postgresjs/mod.js";

const sql = postgres({
  host: "localhost",
  port: 5432,
  database: "mcp_memory",
  username: "postgres",
  password: "your-password",
});

deno run --allow-net --allow-env index.ts

# Install flyctl
curl -L https://fly.io/install.sh | sh

# Launch
fly launch --name my-mcp-server
fly secrets set OPENROUTER_API_KEY=your-key
fly secrets set DATABASE_URL=your-postgres-connection-string
fly deploy

# SSH into your server
# Install Deno
curl -fsSL https://deno.land/install.sh | sh

# Install Postgres + pgvector
sudo apt install postgresql postgresql-contrib
git clone https://github.com/pgvector/pgvector.git
cd pgvector && make && sudo make install

# Set up the database
sudo -u postgres createdb mcp_memory
sudo -u postgres psql mcp_memory < schema.sql

# Set environment variables
export SUPABASE_URL="postgresql://postgres:password@localhost:5432/mcp_memory"
export OPENROUTER_API_KEY="your-key"

# Run with PM2 for persistence
npm install -g pm2
pm2 start "deno run --allow-net --allow-env index.ts" --name mcp-server
pm2 save

FROM denoland/deno:latest
WORKDIR /app
COPY index.ts .
EXPOSE 8000
CMD ["run", "--allow-net", "--allow-env", "index.ts"]

docker build -t persistent-mcp .
docker run -p 8000:8000 \
  -e OPENROUTER_API_KEY=your-key \
  -e SUPABASE_URL=your-db-url \
  -e SUPABASE_SERVICE_ROLE_KEY=your-key \
  persistent-mcp

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull an embedding model
ollama pull nomic-embed-text

async function generateEmbedding(text: string): Promise<number[]> {
  const res = await fetch("http://localhost:11434/api/embeddings", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "nomic-embed-text",
      prompt: text,
    }),
  });
  const data = await res.json();
  return data.embedding;
}

-- Change vector dimensions
ALTER TABLE thoughts ALTER COLUMN embedding TYPE VECTOR(768);

-- Update the match_thoughts function signature
-- Change VECTOR(1536) to VECTOR(768) in the function parameter

async function llmCall(
  prompt: string,
  model = "llama3.2",
  systemPrompt?: string
): Promise<string> {
  const messages = [];
  if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
  messages.push({ role: "user", content: prompt });

  const res = await fetch("http://localhost:11434/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ model, messages, stream: false }),
  });
  const data = await res.json();
  return data.message.content;
}