$ npm i -g @nestjs/cli # Nếu bạn chưa cài đặt Nest.js trên máy của mình
$ nest new project-name

"dependencies": {
  "@langchain/community": "^0.3.53",
  "@langchain/core": "^0.3.75",
  "@langchain/google-genai": "^0.2.16",
  "@langchain/langgraph": "^0.4.8",
  "@langchain/langgraph-checkpoint-mongodb": "^0.1.1",
  "@langchain/mongodb": "^0.1.0",
  "@nestjs/mongoose": "^11.0.3",
  "langchain": "^0.3.33",
  "mongodb": "^6.19.0",
  "mongoose": "^8.18.1",
  "zod": "^4.1.8"
}

import z from 'zod';
import { StructuredOutputParser } from 'langchain/output_parsers';

export const DrinkSchema = z.object({
  name: z.string(),
  description: z.string(),
  supportMilk: z.boolean(),
  supportSweeteners: z.boolean(),
  supportSyrup: z.boolean(),
  supportTopping: z.boolean(),
  supportSize: z.boolean(),
  image: z.string().url().optional(),
});

export const SweetenerSchema = z.object({
  name: z.string(),
  description: z.string(),
  image: z.string().url().optional(),
});

export const SyrupSchema = z.object({
  name: z.string(),
  description: z.string(),
  image: z.string().url().optional(),
});

export const ToppingSchema = z.object({
  name: z.string(),
  description: z.string(),
  image: z.string().url().optional(),
});

export const SizeSchema = z.object({
  name: z.string(),
  description: z.string(),
  image: z.string().url().optional(),
});

export const MilkSchema = z.object({
  name: z.string(),
  description: z.string(),
  image: z.string().url().optional(),
});

export const DrinksSchema = z.array(DrinkSchema);

export type Drink = z.infer<typeof DrinkSchema>;
export type Sweetener = z.infer<typeof SweetenerSchema>;
export type Syrup = z.infer<typeof SyrupSchema>;
export type Topping = z.infer<typeof ToppingSchema>;
export type Size = z.infer<typeof SizeSchema>;
export type Milk = z.infer<typeof MilkSchema>;
export type Drinks = z.infer<typeof DrinksSchema>;

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ChatsModule } from './chats/chats.module';
import { MongooseModule } from '@nestjs/mongoose';

@Module({
  imports: [MongooseModule.forRoot(process.env.MONGO_URI), ChatsModule],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

import { Injectable } from '@nestjs/common';
import { MongoClient } from 'mongodb';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { tool } from '@langchain/core/tools';
import { ChatPromptTemplate, MessagesPlaceholder } from '@langchain/core/prompts';
import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
import { StateGraph } from '@langchain/langgraph';
import { ToolNode } from '@langchain/langgraph/prebuilt';
import { Annotation } from '@langchain/langgraph';
import { AIMessage, BaseMessage, HumanMessage } from '@langchain/core/messages';
import { START, END } from '@langchain/langgraph';
import { MongoDBSaver } from '@langchain/langgraph-checkpoint-mongodb';
import { Order } from 'src/data/schema/order.schema';
import { OrderSchema as OrderSchemaData, OrderParser } from 'src/util/schemas/orders/Order.schema';
import { DrinkParser } from 'src/util/schemas/drinks/Drink.schema';
import { DRINKS } from 'src/util/constants/drinks_data';
import { availableToppingsSummary, createDrinkItemSummary, createSweetenersSummary, createAvailableMilksSummary, createSyrupsSummary, createSizesSummary } from 'src/util/summaries/drink';
import z from 'zod';

const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY || '';
const client: MongoClient = new MongoClient(process.env.MONGO_URI || '');
const database_name = 'drinks_db';

@Injectable()
export class ChatService {
  constructor(@InjectModel(Order.name) private orderModel: Model<Order>) {}

  chatWithAgent = async (thread_id: string, query: string) => {
    await client.connect();
    const graphState = Annotation.Root({
      messages: Annotation<BaseMessage[]>({ reducer: (x, y) => [...x, ...y] }),
    });

    const orderTool = tool(
      async ({ order }: { order: OrderType }) => {
        try {
          await this.orderModel.create(order);
          return 'Order created successfully';
        } catch (error) {
          return 'Failed to create the order';
        }
      },
      {
        schema: z.object({
          order: OrderSchemaData.describe('This is the order that will be passed to '),
        }),
        name: 'create_order',
        description: 'Creates a new order in the database',
      },
    );

    const tools = [orderTool];

    const callModal = async (states: typeof graphState.State) => {
      const prompt = ChatPromptTemplate.fromMessages([
        {
          role: 'system',
          content: `
            Your are a helpful assistant that helps people buy drinks from starbucks.
            You take the user request and find missing details based on how a full order looks like.
            A full order looks like this:  ${OrderParser.getFormatInstructions()}.

            *IMPORTANT
            You have access to a create_order tool, this tool is used to create orders in the database and you should call it when
            you want to create an order.

            You should confirm the order once the tool call has been successful, and if it fails you inform the user.

            **VERY IMPORTANT
            Once the order is ready you should ask the user to confirm and if thet do you should call the create_order right away 
            and only come back to the user once the order has been confirmed or failed.
          `,
        },
        new MessagesPlaceholder('messages'),
      ]);

      const formattedPrompt = await prompt.formatMessages({
        time: new Date().toISOString(),
        messages: states.messages,
      });

      const chat = new ChatGoogleGenerativeAI({
        model: 'gemini-2.0-flash',
        temperature: 0,
        apiKey: GOOGLE_API_KEY,
      }).bindTools(tools);

      const result = await chat.invoke(formattedPrompt);
      return { messages: [result] };
    };

    const shouldContinue = (state: typeof graphState.State) => {
      const messages = state.messages;
      const lastMessage = messages[messages.length - 1] as AIMessage;
      return lastMessage.tool_calls?.length ? 'tools' : END;
    };

    const toolsNode = new ToolNode<typeof graphState.State>(tools);

    const graph = new StateGraph(graphState)
      .addNode('agent', callModal)
      .addNode('tools', toolsNode)
      .addEdge(START, 'agent')
      .addConditionalEdges('agent', shouldContinue)
      .addEdge('tools', 'agent');

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

    const finalState = await app.invoke(
      { messages: [new HumanMessage(query)] },
      { recursionLimit: 15, configurable: { thread_id } },
    );

    function extractJson(response: any) {
      const match = response.match(/```
\s*json\s*([\s\S]*?)\s*```/i);
      if (match && match[1]) {
        return JSON.parse(match[1].trim());
      }
      throw response;
    }

    const lastMessage = finalState.messages.at(-1) as AIMessage;
    return extractJson(lastMessage.content);
  };
}