एजेंट मेमोरी सिस्टम: अपनी AI को स्थायी संदर्भ देना

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface Message {
  role: "user" | "assistant";
  content: string;
}

// बफर में पूरा कन्वर्सेशन हिस्ट्री होता है
const buffer: Message[] = [];

async function chat(userMessage: string): Promise<string> {
  // नया यूज़र मेसेज बफर में जोड़ें
  buffer.push({ role: "user", content: userMessage });

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    // हर कॉल पर पूरा बफर पास करें
    messages: buffer,
  });

  const assistantMessage =
    response.content[0].type === "text" ? response.content[0].text : "";

  // असिस्टेंट का जवाब बफर में जोड़ें
  buffer.push({ role: "assistant", content: assistantMessage });

  return assistantMessage;
}

// उपयोग उदाहरण
await chat("मेरा नाम Alex है और मैं TypeScript से ज़्यादा Python पसंद करता हूँ।");
await chat("मुझे अपने अगले प्रोजेक्ट के लिए कौन सी भाषा इस्तेमाल करनी चाहिए?");
// मॉडल को पहले मेसेज में बताई गई प्राथमिकता याद है

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface ConversationState {
  summary: string;       // पुराने टर्न का संपीड़ित हिस्ट्री
  recentMessages: Array<{ role: "user" | "assistant"; content: string }>;
  maxRecentTurns: number; // अंतिम N टर्न शब्दशः रखें
}

const state: ConversationState = {
  summary: "",
  recentMessages: [],
  maxRecentTurns: 6, // 3 यूज़र + 3 असिस्टेंट टर्न
};

// पुराने टर्न को रोलिंग सारांश में संपीड़ित करें
async function compressSummary(
  currentSummary: string,
  messagesToCompress: Array<{ role: string; content: string }>
): Promise<string> {
  const formatted = messagesToCompress
    .map((m) => `${m.role.toUpperCase()}: ${m.content}`)
    .join("\n");

  const response = await client.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 512,
    messages: [
      {
        role: "user",
        content: `नीचे दिए गए नए एक्सचेंज जोड़कर कन्वर्सेशन सारांश अपडेट करें।
केवल अपडेट किया गया सारांश वापस करें। इसे 200 शब्दों से कम रखें।

वर्तमान सारांश:
${currentSummary || "(कोई नहीं)"}

नए एक्सचेंज:
${formatted}`,
      },
    ],
  });

  return response.content[0].type === "text" ? response.content[0].text : currentSummary;
}

async function chat(userMessage: string): Promise<string> {
  // जब बफर सीमा से अधिक हो, सबसे पुराने आधे को संपीड़ित करें
  if (state.recentMessages.length >= state.maxRecentTurns * 2) {
    const toCompress = state.recentMessages.splice(0, state.maxRecentTurns);
    state.summary = await compressSummary(state.summary, toCompress);
  }

  state.recentMessages.push({ role: "user", content: userMessage });

  // मेसेज अरे बनाएं: सिस्टम सारांश + हाल के शब्दशः टर्न
  const messages = [
    ...(state.summary
      ? [
          {
            role: "user" as const,
            content: `इस बातचीत में पहले का संदर्भ:\n${state.summary}`,
          },
          {
            role: "assistant" as const,
            content: "समझ गया। मैं उस संदर्भ का उपयोग करूँगा।",
          },
        ]
      : []),
    ...state.recentMessages,
  ];

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages,
  });

  const assistantMessage =
    response.content[0].type === "text" ? response.content[0].text : "";

  state.recentMessages.push({ role: "assistant", content: assistantMessage });
  return assistantMessage;
}

import Anthropic from "@anthropic-ai/sdk";
import fs from "fs/promises";

const client = new Anthropic();

// प्रोडक्शन में, इस फाइल स्टोर को Redis या डेटाबेस से बदलें
const MEMORY_PATH = "./memory.json";

interface EpisodicStore {
  [userId: string]: Record<string, string>;
}

async function loadMemory(): Promise<EpisodicStore> {
  try {
    const data = await fs.readFile(MEMORY_PATH, "utf-8");
    return JSON.parse(data);
  } catch {
    return {};
  }
}

async function saveMemory(store: EpisodicStore): Promise<void> {
  await fs.writeFile(MEMORY_PATH, JSON.stringify(store, null, 2));
}

// नवीनतम एक्सचेंज से संरचित तथ्य निकालें
async function extractFacts(
  userMessage: string,
  assistantReply: string
): Promise<Record<string, string>> {
  const response = await client.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 256,
    messages: [
      {
        role: "user",
        content: `इस एक्सचेंज से कोई भी व्यक्तिगत तथ्य, प्राथमिकताएं या महत्वपूर्ण निर्णय निकालें।
की-वैल्यू पेयर का JSON ऑब्जेक्ट वापस करें। यदि याद रखने योग्य कुछ नहीं है तो {} वापस करें।

यूज़र: ${userMessage}
असिस्टेंट: ${assistantReply}`,
      },
    ],
  });

  try {
    const text = response.content[0].type === "text" ? response.content[0].text : "{}";
    const match = text.match(/\{[\s\S]*\}/);
    return match ? JSON.parse(match[0]) : {};
  } catch {
    return {};
  }
}

// संग्रहीत तथ्यों को सिस्टम प्रॉम्प्ट इंजेक्शन के रूप में फॉर्मेट करें
function formatMemory(facts: Record<string, string>): string {
  const entries = Object.entries(facts);
  if (entries.length === 0) return "";
  return (
    "इस यूज़र के बारे में आप क्या जानते हैं:\n" +
    entries.map(([k, v]) => `- ${k}: ${v}`).join("\n")
  );
}

async function chat(userId: string, userMessage: string): Promise<string> {
  const store = await loadMemory();
  const userFacts = store[userId] ?? {};

  const systemPrompt = formatMemory(userFacts);

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    system: systemPrompt || undefined,
    messages: [{ role: "user", content: userMessage }],
  });

  const assistantMessage =
    response.content[0].type === "text" ? response.content[0].text : "";

  // तथ्य निकालें और भविष्य के सेशन के लिए उन्हें persist करें
  const newFacts = await extractFacts(userMessage, assistantMessage);
  if (Object.keys(newFacts).length > 0) {
    store[userId] = { ...userFacts, ...newFacts };
    await saveMemory(store);
  }

  return assistantMessage;
}

// सेशन 1
await chat("user-123", "मैं संक्षिप्त उत्तर पसंद करता हूँ। जब तक ज़रूरी न हो बुलेट पॉइंट नहीं।");
// सेशन 2 (कुछ दिन बाद एक अलग प्रोसेस)
await chat("user-123", "TCP हैंडशेक कैसे काम करता है, समझाएं।");
// एजेंट को सेशन 1 की फॉर्मेटिंग प्राथमिकता याद है

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface Document {
  id: string;
  content: string;
  embedding?: number[];
}

// दो वेक्टर के बीच कोसाइन समानता की गणना करें
function cosineSimilarity(a: number[], b: number[]): number {
  const dot = a.reduce((sum, val, i) => sum + val * b[i], 0);
  const magA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
  const magB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
  return dot / (magA * magB);
}

class SemanticMemory {
  private documents: Document[] = [];

  // बाद में रिट्रीवल के लिए दस्तावेज़ इंडेक्स करें
  async add(id: string, content: string): Promise<void> {
    const embedding = await embed(content); // एक डेडिकेटेड एम्बेडिंग मॉडल इस्तेमाल करें
    this.documents.push({ id, content, embedding });
  }

  // किसी क्वेरी के लिए सबसे प्रासंगिक k दस्तावेज़ रिट्रीव करें
  async search(query: string, topK = 3): Promise<Document[]> {
    const queryEmbedding = await embed(query);
    return this.documents
      .filter((doc) => doc.embedding)
      .map((doc) => ({
        doc,
        score: cosineSimilarity(queryEmbedding, doc.embedding!),
      }))
      .sort((a, b) => b.score - a.score)
      .slice(0, topK)
      .map(({ doc }) => doc);
  }
}

const memory = new SemanticMemory();

async function answerWithContext(question: string): Promise<string> {
  // प्रासंगिक दस्तावेज़ रिट्रीव करें
  const relevant = await memory.search(question);
  const context = relevant.map((d) => d.content).join("\n\n---\n\n");

  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    system: context
      ? `निम्नलिखित संदर्भ का उपयोग करके प्रश्न का उत्तर दें:\n\n${context}`
      : undefined,
    messages: [{ role: "user", content: question }],
  });

  return response.content[0].type === "text" ? response.content[0].text : "";
}

// उदाहरण: नॉलेज बेस इंडेक्स करें और क्वेरी करें
await memory.add("doc-1", "टीम React 18 और app router पैटर्न का उपयोग करती है।");
await memory.add("doc-2", "सभी API रूट को Zod स्कीमा के साथ इनपुट वैलिडेट करना होगा।");
await memory.add("doc-3", "डेटाबेस क्वेरी Drizzle ORM इस्तेमाल करती हैं। Raw SQL से बचें।");

const answer = await answerWithContext("मुझे नया API एंडपॉइंट कैसे लिखना चाहिए?");
// एजेंट doc-2 और doc-3 रिट्रीव करता है और एक आधारित उत्तर देता है

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  { name: "memory-server", version: "1.0.0" },
  { capabilities: { tools: {}, resources: {} } }
);

// उपकरण: एक तथ्य स्टोर करें
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "remember") {
    const { key, value, userId } = request.params.arguments as {
      key: string;
      value: string;
      userId: string;
    };
    await storeEpisodicFact(userId, key, value);
    return { content: [{ type: "text", text: `स्टोर किया: ${key} = ${value}` }] };
  }

  if (request.params.name === "recall") {
    const { userId } = request.params.arguments as { userId: string };
    const facts = await loadEpisodicFacts(userId);
    return {
      content: [{ type: "text", text: JSON.stringify(facts, null, 2) }],
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);