Chatbot'lardan Otonom Agent'lara: Mimari Desenler

interface ChatbotMessage {  role: "user" | "assistant";  content: string;}
interface Intent {  name: string;  confidence: number;  entities: Record<string, any>;}
class TraditionalChatbot {  private conversationHistory: ChatbotMessage[] = [];
  async processMessage(userMessage: string): Promise<string> {    // History'ye ekle (son N mesajla sınırlı)    this.conversationHistory.push({ role: "user", content: userMessage });    if (this.conversationHistory.length > 10) {      this.conversationHistory.shift(); // En eskiyi at    }
    // Intent classification    const intent = await this.classifyIntent(userMessage);
    // Intent'e göre handler'a route et    switch (intent.name) {      case "check_order":        return await this.handleOrderCheck(intent.entities);      case "return_request":        return await this.handleReturnRequest(intent.entities);      case "product_question":        return await this.handleProductQuestion(intent.entities);      default:        return "Bunu nasıl yardımcı olacağımdan emin değilim. Yeniden ifade edebilir misin?";    }  }
  private async classifyIntent(message: string): Promise<Intent> {    // NLU servisi veya LLM'e intent classification çağrısı    const response = await fetch("https://api.nlp-service.com/classify", {      method: "POST",      body: JSON.stringify({ text: message })    });    return response.json();  }
  private async handleOrderCheck(entities: Record<string, any>): Promise<string> {    // Sabit flow: order ID çıkar → database sorgusu → response formatla    const orderId = entities.order_id;    if (!orderId) {      return "Sipariş numaran nedir?";    }
    const order = await this.fetchOrder(orderId);    return `Sipariş ${orderId} durumu ${order.status}. Tahmini teslimat: ${order.eta}`;  }
  private async fetchOrder(orderId: string): Promise<any> {    // Database query implementasyonu    return { status: "kargoda", eta: "2025-12-05" };  }}

interface Tool {  name: string;  description: string;  parameters: Record<string, any>;  execute: (params: any) => Promise<any>;}
interface AgentStep {  thought: string;  action?: { tool: string; input: any };  observation?: any;}
class ReActAgent {  private tools: Map<string, Tool>;  private memory: ConversationMemory;  private maxIterations = 10;
  constructor(tools: Tool[], memorySystem: ConversationMemory) {    this.tools = new Map(tools.map(t => [t.name, t]));    this.memory = memorySystem;  }
  async processTask(task: string): Promise<string> {    const steps: AgentStep[] = [];    let finalAnswer: string | null = null;
    // Memory'den ilgili context'i al    const context = await this.memory.retrieve(task);
    for (let i = 0; i < this.maxIterations; i++) {      // Sonraki adımı generate et: thought + action      const step = await this.generateNextStep(task, steps, context);      steps.push(step);
      // Final cevap var mı kontrol et      if (!step.action) {        finalAnswer = step.thought;        break;      }
      // Action'ı execute et      const tool = this.tools.get(step.action.tool);      if (!tool) {        step.observation = { error: `Tool ${step.action.tool} bulunamadı` };        continue;      }
      try {        const result = await tool.execute(step.action.input);        step.observation = result;      } catch (error) {        step.observation = { error: error.message };      }    }
    // Conversation'ı long-term memory'de sakla    await this.memory.store(task, steps, finalAnswer);
    return finalAnswer || "Bu task'ı iteration limiti içinde tamamlayamadım.";  }
  private async generateNextStep(    task: string,    previousSteps: AgentStep[],    context: any  ): Promise<AgentStep> {    // ReAct pattern'iyle prompt oluştur    const prompt = this.buildReActPrompt(task, previousSteps, context);
    // Thought ve action generate etmek için LLM çağır    const response = await this.callLLM(prompt);
    // Response'u structured step'e parse et    return this.parseReActResponse(response);  }
  private buildReActPrompt(task: string, steps: AgentStep[], context: any): string {    const toolDescriptions = Array.from(this.tools.values())      .map(t => `${t.name}: ${t.description}`)      .join("\n");
    const stepHistory = steps.map((s, i) =>      `Adim ${i + 1}:\nDusunce: ${s.thought}\n` +      (s.action ? `Aksiyon: ${s.action.tool}(${JSON.stringify(s.action.input)})\n` : "") +      (s.observation ? `Gozlem: ${JSON.stringify(s.observation)}\n` : "")    ).join("\n");
    return `Tool'ları kullanarak reasoning yapan bir AI agent'sın.
Gorev: ${task}
Mevcut Tool'lar:${toolDescriptions}
Memory'den Ilgili Context:${JSON.stringify(context, null, 2)}
Onceki Adimlar:${stepHistory || "Henuz yok"}
Ne yapacagini dusunup bir tool secerek sonraki adimi generate et.Cevaplamak icin yeterli bilgin varsa, action yerine final cevabi ver.
Format:Dusunce: [bir sonraki adim hakkinda reasoning'in]Aksiyon: [tool_name]Input: [JSON olarak tool input]
VEYA cevaplamaya hazirsan:Dusunce: [final reasoning]Cevap: [gorev icin final cevap]`;  }
  private parseReActResponse(response: string): AgentStep {    // LLM output'unu structured step'e parse et    const thoughtMatch = response.match(/Dusunce: (.+?)(?=\n|$)/s);    const actionMatch = response.match(/Aksiyon: (.+?)(?=\n|$)/);    const inputMatch = response.match(/Input: (.+?)(?=\n|$)/s);    const answerMatch = response.match(/Cevap: (.+?)(?=\n|$)/s);
    const thought = thoughtMatch?.[1].trim() || "";
    if (answerMatch) {      // Final cevap, action yok      return { thought: answerMatch[1].trim() };    }
    if (actionMatch && inputMatch) {      return {        thought,        action: {          tool: actionMatch[1].trim(),          input: JSON.parse(inputMatch[1].trim())        }      };    }
    return { thought };  }
  private async callLLM(prompt: string): Promise<string> {    // LLM API çağrısı (Anthropic, OpenAI, vs.)    throw new Error("LLM entegrasyonu implement et");  }}

interface Task {  id: string;  description: string;  status: "pending" | "in-progress" | "completed" | "failed";  dependencies: string[];  result?: any;  error?: string;  metadata?: any;}
interface ExecutionPlan {  goal: string;  tasks: Task[];  strategy: string;}
class PlanAndExecuteAgent {  private tools: Map<string, Tool>;  private memory: ConversationMemory;
  async execute(goal: string): Promise<any> {    // Faz 1: Planning    console.error("[Planning Fazi] Goal'i task'lara ayiriyor...");    const plan = await this.createPlan(goal);    console.error(`[Planning Fazi] ${plan.tasks.length} task ile plan olusturuldu`);
    // Faz 2: Execution    console.error("[Execution Fazi] Task'lar execute ediliyor...");    const results = await this.executePlan(plan);
    // Faz 3: Synthesis    console.error("[Synthesis Fazi] Sonuclar birlestiriliyor...");    const finalResult = await this.synthesizeResults(goal, plan, results);
    return finalResult;  }
  private async createPlan(goal: string): Promise<ExecutionPlan> {    // Memory'den ilgili geçmiş plan'ları al    const pastExperiences = await this.memory.retrieve(goal);
    const planningPrompt = `Bir planning agent'sın. Bu goal'i executable task'lara ayır.
Goal: ${goal}
Mevcut Tool'lar:${Array.from(this.tools.values()).map(t => `- ${t.name}: ${t.description}`).join("\n")}
Benzer Gecmis Task'lar:${JSON.stringify(pastExperiences, null, 2)}
Soyle task'larla plan olustur:1. Mumkun oldugunda independent (paralel execution icin)2. Dependency'leri explicit belirt3. Mevcut tool'lara map'le4. Verification adimlarini icersin
Return formati:{  "strategy": "yaklasimin aciklamasi",  "tasks": [    {      "id": "task-1",      "description": "ne yapilacak",      "tool": "tool_name",      "dependencies": [],      "params": {}    }  ]}`;
    const planResponse = await this.callLLM(planningPrompt);    const planData = JSON.parse(planResponse);
    return {      goal,      strategy: planData.strategy,      tasks: planData.tasks.map((t: any) => ({        id: t.id,        description: t.description,        status: "pending" as const,        dependencies: t.dependencies || [],        metadata: { tool: t.tool, params: t.params }      }))    };  }
  private async executePlan(plan: ExecutionPlan): Promise<Map<string, any>> {    const results = new Map<string, any>();    const taskMap = new Map(plan.tasks.map(t => [t.id, t]));
    // Dependency'leri respect ederek task'ları execute et    while (results.size < plan.tasks.length) {      // Execute etmeye hazır task'ları bul (pending dependency yok)      const readyTasks = plan.tasks.filter(task => {        if (task.status !== "pending") return false;
        return task.dependencies.every(depId => {          const depTask = taskMap.get(depId);          return depTask?.status === "completed";        });      });
      if (readyTasks.length === 0) {        // Takılıp kalmadık mı kontrol et (circular dependency veya hepsi failed)        const pendingTasks = plan.tasks.filter(t => t.status === "pending");        if (pendingTasks.length > 0) {          console.error("[Execution Fazi] Takildi - circular dependency tespit edildi");          break;        }        break;      }
      // Hazır task'ları paralel execute et      console.error(`[Execution Fazi] ${readyTasks.length} task paralel execute ediliyor`);      await Promise.all(        readyTasks.map(task => this.executeTask(task, results))      );    }
    return results;  }
  private async executeTask(task: Task, results: Map<string, any>): Promise<void> {    task.status = "in-progress";    console.error(`[Task ${task.id}] Basliyor: ${task.description}`);
    try {      // Dependency sonuçlarını al      const depResults = task.dependencies.reduce((acc, depId) => {        acc[depId] = results.get(depId);        return acc;      }, {} as Record<string, any>);
      // Tool'u parametreler ve dependency sonuçlarıyla execute et      const tool = this.tools.get(task.metadata.tool);      if (!tool) {        throw new Error(`Tool ${task.metadata.tool} bulunamadi`);      }
      const params = {        ...task.metadata.params,        dependencyResults: depResults      };
      const result = await tool.execute(params);
      task.status = "completed";      task.result = result;      results.set(task.id, result);
      console.error(`[Task ${task.id}] Basariyla tamamlandi`);    } catch (error) {      task.status = "failed";      task.error = error.message;      results.set(task.id, { error: error.message });
      console.error(`[Task ${task.id}] Basarisiz: ${error.message}`);    }  }
  private async synthesizeResults(    goal: string,    plan: ExecutionPlan,    results: Map<string, any>  ): Promise<any> {    const synthesisPrompt = `Bir goal'e ulasmak icin plan execute ettin. Sonuclari coherent bir cevap haline getir.
Goal: ${goal}
Plan Stratejisi: ${plan.strategy}
Task Sonuclari:${Array.from(results.entries()).map(([id, result]) =>  `${id}: ${JSON.stringify(result)}`).join("\n")}
Original goal'i adreslemeyen comprehensive bir cevap ver, tum task'lardan insight'ları dahil et.`;
    const synthesis = await this.callLLM(synthesisPrompt);
    // Basarili plan'i future reference icin memory'de sakla    if (results.size === plan.tasks.length) {      await this.memory.store(goal, { plan, results: Array.from(results.entries()) }, synthesis);    }
    return synthesis;  }
  private async callLLM(prompt: string): Promise<string> {    throw new Error("LLM entegrasyonu implement et");  }}

interface MemoryEntry {  timestamp: Date;  content: any;  metadata: Record<string, any>;  embedding?: number[];}
// Basit buffer memory (chatbot tarzı)class BufferMemory {  private buffer: MemoryEntry[] = [];  private maxSize = 10;
  async store(content: any, metadata: Record<string, any> = {}): Promise<void> {    this.buffer.push({ timestamp: new Date(), content, metadata });    if (this.buffer.length > this.maxSize) {      this.buffer.shift(); // FIFO eviction    }  }
  async retrieve(query: string): Promise<any[]> {    // Tüm buffer içeriğini döndür (filtreleme yok)    return this.buffer.map(e => e.content);  }
  async clear(): Promise<void> {    this.buffer = [];  }}
// Vector tabanlı long-term memory (agent tarzı)class VectorMemory {  private vectorStore: VectorDatabase;  private embeddingModel: EmbeddingModel;
  constructor(vectorStore: VectorDatabase, embeddingModel: EmbeddingModel) {    this.vectorStore = vectorStore;    this.embeddingModel = embeddingModel;  }
  async store(content: any, metadata: Record<string, any> = {}): Promise<void> {    // Semantic search için embedding generate et    const text = this.contentToText(content);    const embedding = await this.embeddingModel.embed(text);
    await this.vectorStore.insert({      timestamp: new Date(),      content,      metadata: {        ...metadata,        importance: this.calculateImportance(content, metadata)      },      embedding    });  }
  async retrieve(query: string, options: { limit?: number; threshold?: number } = {}): Promise<any[]> {    // Embedding'ler kullanarak semantic search    const queryEmbedding = await this.embeddingModel.embed(query);
    const results = await this.vectorStore.search({      embedding: queryEmbedding,      limit: options.limit || 5,      threshold: options.threshold || 0.7    });
    // En ilgili memory'leri, recency ve importance'a göre ağırlıklandırarak döndür    return results      .map(r => ({        content: r.content,        relevance: r.similarity,        recency: this.calculateRecency(r.timestamp),        importance: r.metadata.importance      }))      .sort((a, b) => {        const scoreA = a.relevance * 0.6 + a.recency * 0.2 + a.importance * 0.2;        const scoreB = b.relevance * 0.6 + b.recency * 0.2 + b.importance * 0.2;        return scoreB - scoreA;      })      .map(r => r.content);  }
  async forget(criteria: { olderThan?: Date; importance?: number }): Promise<void> {    // Zamana ve importance'a göre selective forgetting    const deleteFilter: any = {};
    if (criteria.olderThan) {      deleteFilter.timestamp = { $lt: criteria.olderThan };    }    if (criteria.importance !== undefined) {      deleteFilter["metadata.importance"] = { $lt: criteria.importance };    }
    await this.vectorStore.delete(deleteFilter);  }
  private calculateImportance(content: any, metadata: Record<string, any>): number {    // Heuristik scoring: user correction'ları, explicit feedback, task outcome'ları    let score = 0.5; // baseline
    if (metadata.userCorrection) score += 0.3;    if (metadata.explicitFeedback) score += 0.2;    if (metadata.taskSuccess === false) score += 0.15; // Failure'lardan öğren    if (metadata.toolError) score += 0.1; // Issue'ları hatırla
    return Math.min(score, 1.0);  }
  private calculateRecency(timestamp: Date): number {    const ageMs = Date.now() - timestamp.getTime();    const ageDays = ageMs / (1000 * 60 * 60 * 24);
    // Exponential decay: taze memory'ler daha yüksek score alır    return Math.exp(-ageDays / 30); // 30 günlük half-life  }
  private contentToText(content: any): string {    if (typeof content === "string") return content;    return JSON.stringify(content);  }}
// Production agent'lar için hybrid memory sistemclass HybridMemory implements ConversationMemory {  private shortTerm: BufferMemory;  private longTerm: VectorMemory;
  constructor(vectorStore: VectorDatabase, embeddingModel: EmbeddingModel) {    this.shortTerm = new BufferMemory();    this.longTerm = new VectorMemory(vectorStore, embeddingModel);  }
  async store(task: string, steps: any[], result: any): Promise<void> {    // Immediate recall için short-term'de sakla    await this.shortTerm.store({ task, steps, result });
    // Semantic retrieval için long-term'de sakla    await this.longTerm.store(      { task, steps, result },      {        taskSuccess: result !== null,        stepCount: steps.length,        timestamp: new Date()      }    );  }
  async retrieve(query: string): Promise<any> {    // Her iki memory sistemini birleştir    const recent = await this.shortTerm.retrieve(query);    const relevant = await this.longTerm.retrieve(query, { limit: 3 });
    return {      recentContext: recent,      relevantExperiences: relevant    };  }}

async function reactLoopWithDetection(task: string) {  const actionHistory = new Set<string>();
  for (let i = 0; i < maxIterations; i++) {    const step = await generateStep();
    // Bu action'ın signature'ını oluştur    const actionSignature = `${step.action.tool}:${JSON.stringify(step.action.input)}`;
    if (actionHistory.has(actionSignature)) {      console.error("[Loop Tespit Edildi] Tekrarlanan action'dan cikiliyor");      return { error: "Agent loop'ta takildi, sonlandiriliyor" };    }
    actionHistory.add(actionSignature);    await executeStep(step);  }}

class ManagedConversationHistory {  private messages: Message[] = [];  private maxMessages = 20;  private summaries: string[] = [];
  async add(message: Message) {    this.messages.push(message);
    if (this.messages.length > this.maxMessages) {      // En eski 10 mesajı summarize et      const toSummarize = this.messages.splice(0, 10);      const summary = await this.summarize(toSummarize);      this.summaries.push(summary);    }  }
  getContext(): string {    return [      ...this.summaries.map(s => `[Ozet] ${s}`),      ...this.messages.map(m => `${m.role}: ${m.content}`)    ].join("\n");  }}

class HybridChatbotAgent {  private intentClassifier: IntentClassifier;  private agentMode: boolean = false;
  async process(message: string): Promise<string> {    // Önce intent-based handling dene (hızlı, ucuz)    const intent = await this.intentClassifier.classify(message);
    if (intent.confidence > 0.85 && !intent.requiresToolUse) {      // Geleneksel chatbot flow kullan      return await this.handleIntent(intent);    }
    // Karmaşık query'ler için agent mode'a geç    console.error("[Hybrid] Karmasik query icin agent mode'a geciliyor");    this.agentMode = true;    return await this.agentProcess(message);  }}