Construa um agente de IA com LangGraph.js e o MongoDB Atlas

npm init -y
npm i -D typescript ts-node @types/express @types/node
npx tsc --init
npm i langchain @langchain/langgraph @langchain/mongodb @langchain/community @langchain/langgraph-checkpoint-mongodb dotenv express mongodb zod

OPENAI_API_KEY = "<openai-api-key>"
MONGODB_URI = "<connection-string>"
VOYAGEAI_API_KEY = "<voyage-api-key>"

import { MongoClient } from "mongodb";
import 'dotenv/config';
const client = new MongoClient(process.env.MONGODB_URI as string);
async function startServer() {
  try {
    await client.connect();
    await client.db("admin").command({ ping: 1 });
    console.log("Pinged your deployment. You successfully connected to MongoDB!");
    // ... rest of the server setup
  } catch (error) {
    console.error("Error connecting to MongoDB:", error);
    process.exit(1);
  }
}
startServer();

{
  "fields": [
    {
      "numDimensions": 1024,
      "path": "embedding",
      "similarity": "cosine",
      "type": "vector"
    }
  ]
}

import { ChatOpenAI } from "@langchain/openai";
import { AIMessage, BaseMessage, HumanMessage } from "@langchain/core/messages";
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
import { StateGraph } from "@langchain/langgraph";
import { Annotation } from "@langchain/langgraph";
import { tool } from "@langchain/core/tools";
import { ToolNode } from "@langchain/langgraph/prebuilt";
import { MongoDBSaver } from "@langchain/langgraph-checkpoint-mongodb";
import { MongoDBAtlasVectorSearch } from "@langchain/mongodb";
import { MongoClient } from "mongodb";
import { z } from "zod";
import "dotenv/config";
export async function callAgent(client: MongoClient, query: string, thread_id: string) {
  // Define the MongoDB database and collection
  const dbName = "hr_database";
  const db = client.db(dbName);
  const collection = db.collection("employees");
  // ... (Add rest of code here)
}

const GraphState = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: (x, y) => x.concat(y),
  }),
});

  const executeQuery = async (embedding:[], n: number) => {
    try {
        const client = new MongoClient(process.env.MONGODB_URI as string);
        const database = client.db("hr_database");
        const coll = database.collection("employees");
        const agg = [
            {
              '$vectorSearch': {
                'index': 'vector_index',
                'path': 'embedding',
                'queryVector': embedding,
                'numCandidates': 150,
                'limit': n
              }
            }, {
              '$project': {
                '_id': 0,
                'pageContent': 1,
                'score': {
                  '$meta': 'vectorSearchScore'
                }
              }
            }
          ];
        const result = await coll.aggregate(agg).toArray();
        return result
    } catch(error) {
        console.log("Error while querying:", error)
    }
  }
  const fetchEmbeddings = async (query: string) => {
    const apiUrl = "https://ai.mongodb.com/v1/embeddings";  
    const apiKey = process.env.VOYAGEAI_API_KEY;
    const requestBody = {  
      input: query,
      model: "voyage-3.5",  
    };  
    
    try {  
      const response = await fetch(apiUrl, {  
        method: "POST",  
        headers: {  
          Authorization: `Bearer ${apiKey}`,  
          "Content-Type": "application/json",  
        },  
        body: JSON.stringify(requestBody),  
      });  
    
      if (!response.ok) {  
        throw new Error(`Error: ${response.status} ${response.statusText}`);  
      }  
    
      const data = await response.json(); 
      return data.data[0].embedding;
    } catch (error) {  
      console.error("Error while fetching embedding:", error);  
    }  
  };
  const employeeLookupTool = tool(
   async ({ query, n = 10 }) => {
     console.log("Employee lookup tool called");
     const embedding = await fetchEmbeddings(query)
     const response = await executeQuery(embedding, n)
     const result = JSON.stringify(response)
     return result;
   },
   {
     name: "employee_lookup",
     description: "Gathers employee details from the HR database",
     schema: z.object({
       query: z.string().describe("The search query"),
       n: z.number().optional().default(10).describe("Number of results to return"),
     }),
   }
  );
  const tools = [employeeLookupTool];
  const toolNode = new ToolNode<typeof GraphState.State>(tools);

const model = new ChatOpenAI({
  model: "gpt-4o"
  }).bindTools(tools);

const workflow = new StateGraph(GraphState)
  .addNode("agent", callModel)
  .addNode("tools", toolNode)
  .addEdge("__start__", "agent")
  .addConditionalEdges("agent", shouldContinue)
  .addEdge("tools", "agent");

const checkpointer = new MongoDBSaver({ client, dbName });
const app = workflow.compile({ checkpointer });

const finalState = await app.invoke(
  {
    messages: [new HumanMessage(query)],
  },
  { recursionLimit: 15, configurable: { thread_id: thread_id } }
);
console.log(finalState.messages[finalState.messages.length - 1].content);
return finalState.messages[finalState.messages.length - 1].content;

import 'dotenv/config';
import express, { Express, Request, Response } from "express";
import { MongoClient } from "mongodb";
import { callAgent } from './agent';
const app: Express = express();
app.use(express.json());
const client = new MongoClient(process.env.MONGODB_URI as string);
async function startServer() {
  try {
    await client.connect();
    await client.db("admin").command({ ping: 1 });
    console.log("Pinged your deployment. You successfully connected to MongoDB!");
    app.get('/', (req: Request, res: Response) => {
      res.send('LangGraph Agent Server');
    });
    app.post('/chat', async (req: Request, res: Response) => {
      const initialMessage = req.body.message;
      const threadId = Date.now().toString();
      try {
        const response = await callAgent(client, initialMessage, threadId);
        res.json({ threadId, response });
      } catch (error) {
        console.error('Error starting conversation:', error);
        res.status(500).json({ error: 'Internal server error' });
      }
    });
    app.post('/chat/:threadId', async (req: Request, res: Response) => {
      const { threadId } = req.params;
      const { message } = req.body;
      try {
        const response = await callAgent(client, message, threadId);
        res.json({ response });
      } catch (error) {
        console.error('Error in chat:', error);
        res.status(500).json({ error: 'Internal server error' });
      }
    });
    const PORT = process.env.PORT || 3000;
    app.listen(PORT, () => {
      console.log(`Server running on port ${PORT}`);
    });
  } catch (error) {
    console.error('Error connecting to MongoDB:', error);
    process.exit(1);
  }
}
startServer();

npx ts-node index.ts