Build a JavaScript AI Agent With LangGraph.js and MongoDB

1
├── .env
2
├── index.ts
3
├── agent.ts
4
├── seed-database.ts
5
├── package.json
6
├── tsconfig.json

1
npm init -y
2
npm i -D typescript ts-node @types/express @types/node
3
npx tsc --init
4
npm i langchain @langchain/langgraph @langchain/mongodb @langchain/langgraph-checkpoint-mongodb @langchain/anthropic dotenv express mongodb zod

1
OPENAI_API_KEY=your-openai-api-key
2
ANTHROPIC_API_KEY=your-anthropic-api-key
3
MONGODB_ATLAS_URI=your-mongodb-atlas-connection-string

1
import { MongoClient } from "mongodb";
2
import 'dotenv/config';
3
4
const client = new MongoClient(process.env.MONGODB_ATLAS_URI as string);
5
6
async function startServer() {
7
  try {
8
    await client.connect();
9
    await client.db("admin").command({ ping: 1 });
10
    console.log("Pinged your deployment. You successfully connected to MongoDB!");
11
12
    // ... rest of the server setup
13
  } catch (error) {
14
    console.error("Error connecting to MongoDB:", error);
15
    process.exit(1);
16
  }
17
}
18
19
startServer();

1
import { ChatOpenAI, OpenAIEmbeddings } from "@langchain/openai";
2
import { StructuredOutputParser } from "@langchain/core/output_parsers";
3
import { MongoClient } from "mongodb";
4
import { MongoDBAtlasVectorSearch } from "@langchain/mongodb";
5
import { z } from "zod";
6
import "dotenv/config";

1
const client = new MongoClient(process.env.MONGODB_ATLAS_URI as string);
2
3
const llm = new ChatOpenAI({
4
  modelName: "gpt-4o-mini",
5
  temperature: 0.7,
6
});

1
const EmployeeSchema = z.object({
2
  employee_id: z.string(),
3
  first_name: z.string(),
4
  last_name: z.string(),
5
  date_of_birth: z.string(),
6
  address: z.object({
7
    street: z.string(),
8
    city: z.string(),
9
    state: z.string(),
10
    postal_code: z.string(),
11
    country: z.string(),
12
  }),
13
  contact_details: z.object({
14
    email: z.string().email(),
15
    phone_number: z.string(),
16
  }),
17
  job_details: z.object({
18
    job_title: z.string(),
19
    department: z.string(),
20
    hire_date: z.string(),
21
    employment_type: z.string(),
22
    salary: z.number(),
23
    currency: z.string(),
24
  }),
25
  work_location: z.object({
26
    nearest_office: z.string(),
27
    is_remote: z.boolean(),
28
  }),
29
  reporting_manager: z.string().nullable(),
30
  skills: z.array(z.string()),
31
  performance_reviews: z.array(
32
    z.object({
33
      review_date: z.string(),
34
      rating: z.number(),
35
      comments: z.string(),
36
    })
37
  ),
38
  benefits: z.object({
39
    health_insurance: z.string(),
40
    retirement_plan: z.string(),
41
    paid_time_off: z.number(),
42
  }),
43
  emergency_contact: z.object({
44
    name: z.string(),
45
    relationship: z.string(),
46
    phone_number: z.string(),
47
  }),
48
  notes: z.string(),
49
});
50
51
type Employee = z.infer<typeof EmployeeSchema>;
52
53
const parser = StructuredOutputParser.fromZodSchema(z.array(EmployeeSchema));

1
async function generateSyntheticData(): Promise<Employee[]> {
2
  const prompt = `You are a helpful assistant that generates employee data. Generate 10 fictional employee records. Each record should include the following fields: employee_id, first_name, last_name, date_of_birth, address, contact_details, job_details, work_location, reporting_manager, skills, performance_reviews, benefits, emergency_contact, notes. Ensure variety in the data and realistic values.
3
4
  ${parser.getFormatInstructions()}`;
5
6
  console.log("Generating synthetic data...");
7
8
  const response = await llm.invoke(prompt);
9
  return parser.parse(response.content as string);
10
}

1
async function createEmployeeSummary(employee: Employee): Promise<string> {
2
  return new Promise((resolve) => {
3
    const jobDetails = `${employee.job_details.job_title} in ${employee.job_details.department}`;
4
    const skills = employee.skills.join(", ");
5
    const performanceReviews = employee.performance_reviews
6
      .map(
7
        (review) =>
8
          `Rated ${review.rating} on ${review.review_date}: ${review.comments}`
9
      )
10
      .join(" ");
11
    const basicInfo = `${employee.first_name} ${employee.last_name}, born on ${employee.date_of_birth}`;
12
    const workLocation = `Works at ${employee.work_location.nearest_office}, Remote: ${employee.work_location.is_remote}`;
13
    const notes = employee.notes;
14
15
    const summary = `${basicInfo}. Job: ${jobDetails}. Skills: ${skills}. Reviews: ${performanceReviews}. Location: ${workLocation}. Notes: ${notes}`;
16
17
    resolve(summary);
18
  });
19
}

1
async function seedDatabase(): Promise<void> {
2
  try {
3
    await client.connect();
4
    await client.db("admin").command({ ping: 1 });
5
    console.log("Pinged your deployment. You successfully connected to MongoDB!");
6
7
    const db = client.db("hr_database");
8
    const collection = db.collection("employees");
9
10
    await collection.deleteMany({});
11
    
12
    const syntheticData = await generateSyntheticData();
13
14
    const recordsWithSummaries = await Promise.all(
15
      syntheticData.map(async (record) => ({
16
        pageContent: await createEmployeeSummary(record),
17
        metadata: {...record},
18
      }))
19
    );
20
    
21
    for (const record of recordsWithSummaries) {
22
      await MongoDBAtlasVectorSearch.fromDocuments(
23
        [record],
24
        new OpenAIEmbeddings(),
25
        {
26
          collection,
27
          indexName: "vector_index",
28
          textKey: "embedding_text",
29
          embeddingKey: "embedding",
30
        }
31
      );
32
33
      console.log("Successfully processed & saved record:", record.metadata.employee_id);
34
    }
35
36
    console.log("Database seeding completed");
37
38
  } catch (error) {
39
    console.error("Error seeding database:", error);
40
  } finally {
41
    await client.close();
42
  }
43
}
44
45
seedDatabase().catch(console.error);

1
npx ts-node seed-database.ts

1
{
2
  "fields": [
3
    {
4
      "numDimensions": 1536,
5
      "path": "embedding",
6
      "similarity": "cosine",
7
      "type": "vector"
8
    }
9
  ]
10
}

1
import { OpenAIEmbeddings } from "@langchain/openai";
2
import { ChatAnthropic } from "@langchain/anthropic";
3
import { AIMessage, BaseMessage, HumanMessage } from "@langchain/core/messages";
4
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
5
import { StateGraph } from "@langchain/langgraph";
6
import { Annotation } from "@langchain/langgraph";
7
import { tool } from "@langchain/core/tools";
8
import { ToolNode } from "@langchain/langgraph/prebuilt";
9
import { MongoDBSaver } from "@langchain/langgraph-checkpoint-mongodb";
10
import { MongoDBAtlasVectorSearch } from "@langchain/mongodb";
11
import { MongoClient } from "mongodb";
12
import { z } from "zod";
13
import "dotenv/config";

1
export async function callAgent(client: MongoClient, query: string, thread_id: string) {
2
  // Define the MongoDB database and collection
3
  const dbName = "hr_database";
4
  const db = client.db(dbName);
5
  const collection = db.collection("employees");
6
7
  // ... (We'll add the rest of the code here)
8
}

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

1
const employeeLookupTool = tool(
2
  async ({ query, n = 10 }) => {
3
    console.log("Employee lookup tool called");
4
5
    const dbConfig = {
6
      collection: collection,
7
      indexName: "vector_index",
8
      textKey: "embedding_text",
9
      embeddingKey: "embedding",
10
    };
11
12
    const vectorStore = new MongoDBAtlasVectorSearch(
13
      new OpenAIEmbeddings(),
14
      dbConfig
15
    );
16
17
    const result = await vectorStore.similaritySearchWithScore(query, n);
18
    return JSON.stringify(result);
19
  },
20
  {
21
    name: "employee_lookup",
22
    description: "Gathers employee details from the HR database",
23
    schema: z.object({
24
      query: z.string().describe("The search query"),
25
      n: z.number().optional().default(10).describe("Number of results to return"),
26
    }),
27
  }
28
);

1
const tools = [employeeLookupTool];
2
  
3
// We can extract the state typing via `GraphState.State`
4
const toolNode = new ToolNode<typeof GraphState.State>(tools);

1
const model = new ChatAnthropic({
2
  model: "claude-3-5-sonnet-20240620",
3
  temperature: 0,
4
}).bindTools(tools);

1
async function callModel(state: typeof GraphState.State) {
2
  const prompt = ChatPromptTemplate.fromMessages([
3
    [
4
      "system",
5
      `You are a helpful AI assistant, collaborating with other assistants. Use the provided tools to progress towards answering the question. If you are unable to fully answer, that's OK, another assistant with different tools will help where you left off. Execute what you can to make progress. If you or any of the other assistants have the final answer or deliverable, prefix your response with FINAL ANSWER so the team knows to stop. You have access to the following tools: {tool_names}.\n{system_message}\nCurrent time: {time}.`,
6
    ],
7
    new MessagesPlaceholder("messages"),
8
  ]);
9
10
  const formattedPrompt = await prompt.formatMessages({
11
    system_message: "You are helpful HR Chatbot Agent.",
12
    time: new Date().toISOString(),
13
    tool_names: tools.map((tool) => tool.name).join(", "),
14
    messages: state.messages,
15
  });
16
17
  const result = await model.invoke(formattedPrompt);
18
19
  return { messages: [result] };
20
}

1
function shouldContinue(state: typeof GraphState.State) {
2
  const messages = state.messages;
3
  const lastMessage = messages[messages.length - 1] as AIMessage;
4
5
  // If the LLM makes a tool call, then we route to the "tools" node
6
  if (lastMessage.tool_calls?.length) {
7
    return "tools";
8
  }
9
  // Otherwise, we stop (reply to the user)
10
  return "__end__";
11
}

1
const workflow = new StateGraph(GraphState)
2
  .addNode("agent", callModel)
3
  .addNode("tools", toolNode)
4
  .addEdge("__start__", "agent")
5
  .addConditionalEdges("agent", shouldContinue)
6
  .addEdge("tools", "agent");

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

1
const finalState = await app.invoke(
2
  {
3
    messages: [new HumanMessage(query)],
4
  },
5
  { recursionLimit: 15, configurable: { thread_id: thread_id } }
6
);
7
8
console.log(finalState.messages[finalState.messages.length - 1].content);
9
10
return finalState.messages[finalState.messages.length - 1].content;

1
import 'dotenv/config';
2
import express, { Express, Request, Response } from "express";
3
import { MongoClient } from "mongodb";
4
import { callAgent } from './agent';
5
6
const app: Express = express();
7
app.use(express.json());
8
9
// Initialize MongoDB client
10
const client = new MongoClient(process.env.MONGODB_ATLAS_URI as string);
11
12
async function startServer() {
13
  try {
14
    await client.connect();
15
    await client.db("admin").command({ ping: 1 });
16
    console.log("Pinged your deployment. You successfully connected to MongoDB!");
17
18
    app.get('/', (req: Request, res: Response) => {
19
      res.send('LangGraph Agent Server');
20
    });
21
22
    app.post('/chat', async (req: Request, res: Response) => {
23
      const initialMessage = req.body.message;
24
      const threadId = Date.now().toString(); 
25
      try {
26
        const response = await callAgent(client, initialMessage, threadId);
27
        res.json({ threadId, response });
28
      } catch (error) {
29
        console.error('Error starting conversation:', error);
30
        res.status(500).json({ error: 'Internal server error' });
31
      }
32
    });
33
34
    app.post('/chat/:threadId', async (req: Request, res: Response) => {
35
      const { threadId } = req.params;
36
      const { message } = req.body;
37
      try {
38
        const response = await callAgent(client, message, threadId);
39
        res.json({ response });
40
      } catch (error) {
41
        console.error('Error in chat:', error);
42
        res.status(500).json({ error: 'Internal server error' });
43
      }
44
    });
45
46
    const PORT = process.env.PORT || 3000;
47
    app.listen(PORT, () => {
48
      console.log(`Server running on port ${PORT}`);
49
    });
50
  } catch (error) {
51
    console.error('Error connecting to MongoDB:', error);
52
    process.exit(1);
53
  }
54
}
55
56
startServer();

1
npx ts-node index.ts

1
curl -X POST -H "Content-Type: application/json" -d '{"message": "Build a team to make an iOS app, and tell me the talent gaps."}' http://localhost:3000/chat

1
{
2
  "threadId": "1695905400000",
3
  "response": "Now that we have gathered information about potential team members, let's analyze the results and build a team for the iOS app development project. I'll also identify any talent gaps we may have.
4
5
  FINAL ANSWER:
6
7
  Based on the employee information we've gathered, here's the proposed team for building an iOS app, along with identified talent gaps:
8
9
  1. iOS Developer:
10
    - We don't have a dedicated iOS developer in our search results. This is a significant talent gap that needs to be addressed.
11
12
  2. UI/UX Designer:
13
    - Linda Green (Employee ID: E003)
14
      Skills: Adobe Photoshop, Illustrator, UX/UI Design
15
      Strengths: Outstanding creativity and design skills, always meets deadlines with high-quality work
16
      Note: Part-time employee, works remotely
17
18
  3. Frontend Developer:
19
    - Isabella Lopez (Employee ID: E009)
20
      Skills: JavaScript, HTML, CSS
21
      Strengths: Great attention to detail and coding skills, enthusiastic about new technologies and frameworks
22
      Note: While not an iOS developer, her frontend skills could be valuable for the app's web components or for learning iOS development
23
24
  4. Project Manager:
25
    - James Brown (Employee ID: E004)
26
      Skills: Agile, Scrum, Leadership
27
      Strengths: Excellent leadership and team management skills, highly experienced in project management
28
29
  5. Backend Developer:
30
    - Alice Johnson (Employee ID: E001)
31
      Skills: Java, Python, SQL
32
      Strengths: Strong team player with excellent problem-solving skills, meets project deadlines
33
34
  Talent Gaps and Recommendations:
35
36
  1. iOS Developer: This is the most critical gap. We need to either:
37
    a) Hire a dedicated iOS developer with experience in Swift and Xcode.
38
    b) Provide intensive iOS development training to Isabella Lopez or Alice Johnson, leveraging their existing programming skills.
39
40
  2. Mobile-specific UI/UX Design: While Linda Green has UX/UI design skills, we should ensure she has experience with mobile app design, specifically for iOS. If not, consider providing additional training or hiring a specialist in iOS app design.
41
42
  3. iOS-specific Project Management: James Brown should familiarize himself with iOS app development lifecycle and any specific methodologies used in mobile app projects.
43
44
  4. Quality Assurance: We don't have a dedicated QA specialist for mobile apps. Consider either hiring one or training an existing team member in iOS app testing.
45
46
  5. DevOps for iOS: Ensure that one of the team members (possibly Alice Johnson) can handle the iOS app deployment process, including working with the App Store and managing continuous integration/continuous deployment (CI/CD) for iOS apps.
47
48
  6. Full-time UI/UX Designer: Since Linda Green is part-time, consider either increasing her hours or hiring an additional full-time UI/UX designer to ensure consistent availability throughout the project.
49
50
  To address these gaps, the company should consider a combination of hiring new talent, providing specialized training to existing employees, and possibly engaging freelancers or consultants for specific iOS development needs. This will ensure a well-rounded team capable of successfully developing and launching an iOS app."

1
curl -X POST -H "Content-Type: application/json" -d '{"message": "What are the talent gaps?"}' http://localhost:3000/chat/<threadId>