MongoDB 8.3: The New Foundation for Building AI Agents

import { MongoClient } from 'mongodb'; const client = new MongoClient('mongodb://localhost:27017');await client.connect(); const db = client.db('ai-agent'); // Create vector indexawait db.collection('memories').createIndex(  { embedding: '2dsphere' },  { type: 'vector', similarity: 'cosine' }); // Find similar memoriesconst query = {  _id: { $ne: agentId },  embedding: {    $near: {      vector: [0.1, 0.5, 0.3, 0.8],      maxDistance: 0.5    }  }}; const similarMemories = await db.collection('memories').find(query).toArray();

import { MongoClient, WithTransactionCallback } from 'mongodb'; export class MemoryManager {  private client: MongoClient;  private db: any;   constructor(connectionString: string) {    this.client = new MongoClient(connectionString);  }   async initialize(): Promise<void> {    await this.client.connect();    this.db = this.client.db('ai-agent');    await this.db.collection('sessions').createIndex(      { agentId: 1, timestamp: -1 }    );  }   async withTransaction<T>(    callback: WithTransactionCallback<T>,    options: any = {}  ): Promise<T> {    return await this.db.withTransaction(callback, {      readPreference: 'primary',      writeConcern: { w: 'majority' },      ...options    });  }   async storeSession(agentId: string, session: any): Promise<void> {    await this.db.collection('sessions').insertOne({      agentId,      ...session,      timestamp: new Date()    });  }   async getRecentSession(agentId: string, limit: number = 10): Promise<any[]> {    return await this.db.collection('sessions')      .find({ agentId })      .sort({ timestamp: -1 })      .limit(limit)      .toArray();  }}

export class AgentOperations {  private memoryManager: MemoryManager;   constructor(memoryManager: MemoryManager) {    this.memoryManager = memoryManager;  }   async executeWithState<T>(    agentId: string,    operationName: string,    data: any,    callback: (state: any) => Promise<T>\n  ): Promise<T> {    return await this.memoryManager.withTransaction(async (session) => {      // Get current state      const currentState = await this.memoryManager.getRecentSession(        agentId, 1      );       // Prepare new state      const newState = {        agentId,        operationName,        data,        previousState: currentState[0] || null,        timestamp: new Date()      };       // Store state      await this.memoryManager.storeSession(agentId, newState);       // Execute operation with state      const result = await callback(newState);       // Verify operation completed atomically      if (!result.success) {        throw new Error(`Operation ${operationName} failed`);      }       return result;    }, {      retryWrites: true,      maxCommitTimeMS: 10000    });  }}

- // Old vector search syntaxawait db.collection('embeddings').find({  vector: { $near: [0.1, 0.5, 0.3] }});+ // New vector search syntaxawait db.collection('embeddings').find({  embedding: {    $near: {      vector: [0.1, 0.5, 0.3],      maxDistance: 0.5    }  }});

import { MemoryManager } from './memory-manager';import { AgentOperations } from './operations'; class SimpleAgent {  private memoryManager: MemoryManager;  private operations: AgentOperations;   constructor() {    this.memoryManager = new MemoryManager(process.env.MONGODB_URI!);    this.operations = new AgentOperations(this.memoryManager);  }   async initialize(): Promise<void> {    await this.memoryManager.initialize();  }   async processUserInput(agentId: string, userInput: string): Promise<string> {    return await this.operations.executeWithState(      agentId,      'process-input',      { userInput },      async (state) => {        // Get relevant memories        const relevantMemories = await this.memoryManager.getRelevantMemories(          agentId,          await this.generateEmbedding(userInput)        );         // Generate response based on context        const response = await this.generateResponse(userInput, relevantMemories);         // Store interaction        await this.memoryManager.storeInteraction(agentId, {          input: userInput,          output: response,          memories: relevantMemories.map(m => m._id)        });         return response;      }    );  }   private async generateEmbedding(text: string): Promise<number[]> {    // In production, this would call an embedding service    return text.split('').map((_, i) => i / 10);  }   private async generateResponse(    input: string,    memories: any[]  ): Promise<string> {    return `Based on your input "${input}" and ${memories.length} relevant memories, here's my response.`;  }   async getRelevantMemories(    agentId: string,    embedding: number[],    limit: number = 5  ): Promise<any[]> {    return await this.memoryManager.getRelevantMemories(agentId, embedding, limit);  }   async storeInteraction(agentId: string, interaction: any): Promise<void> {    await this.memoryManager.storeInteraction(agentId, interaction);  }}

import { SimpleAgent } from './agent'; async function main() {  const agent = new SimpleAgent();  await agent.initialize();   // Process some user input  const agentId = 'test-agent-123';  const userInput = 'How do I implement vector search in MongoDB?';   const response = await agent.processUserInput(agentId, userInput);  console.log('Agent response:', response);} main().catch(console.error);