Membina Chatbot Berkuasa dengan OpenAI dan LangChain

pengenalan

Chatbots ialah alat penting dalam pelbagai industri, menyediakan interaksi automatik dengan pengguna. Tiada orang di dunia hari ini yang tidak mencuba sekurang-kurangnya sekali Sembang GPT (atau mana-mana chatbot berkuasa AI yang lain). Menggunakan model GPT OpenAI dan perpustakaan LangChain, kami boleh membina bot sembang yang mengendalikan sesi dan memproses mesej pengguna melalui sistem respons penstriman, kerana dalam catatan kemudian kami akan berkomunikasi dengan API kami dan membuat ejen yang akan mengkhususkan diri untuk perkara tertentu.

Ini perkara yang akan kami bincangkan:

• Menyediakan pelayan Ekspres dengan perisian tengah.
• Mencipta `AgentManager` untuk mengendalikan ejen chatbot.
• Mencipta ChatAgent untuk mengendalikan ejen chatbot.
• Menstrim balasan chatbot kembali kepada pengguna dalam masa nyata.

Menyediakan Persekitaran

Pertama, kami memerlukan beberapa kebergantungan utama:

• Ekspres untuk mengendalikan permintaan API.
• LangChain untuk mengurus model dan alatan GPT.
• OpenAI untuk interaksi model GPT. Kami perlu mendapatkan token daripada Open AI untuk menggunakan sesi spawn dan berinteraksi dengan chatbot

Pasang Ketergantungan

Perkara pertama yang kami lakukan ialah memulakan projek baharu dan memasang modul yang diperlukan yang akan kami gunakan.

npm init -Y
npm install express langchain openai uuid class-validator class-transformer mutex

Menyediakan Laluan Ekspres

Untuk bermula, kami akan mentakrifkan dua laluan utama:

Laluan pertama akan membuat sesi sembang baharu, manakala laluan kedua akan menghantar mesej ke sesi sedia ada.

router.post('/session', APIKeyMiddleware, createSession);
router.post('/session/:id/message', APIKeyMiddleware, postMessage);

APIKeyMiddleware memastikan bahawa hanya permintaan yang disahkan mengakses laluan ini. Ambil perhatian bahawa anda boleh melaksanakan perisian tengah yang sesuai dengan keperluan anda.

Mencipta Pengurus Ejen

Kami akan membuat kelas AgentManager untuk mengendalikan ejen sembang. Kelas ini bertanggungjawab untuk mencipta ejen baharu dan mengurus sesi aktif, jadi bayangkan kelas ini sebagai pintu masuk utama untuk API kami kerana ia akan mempunyai ejen yang akan bertanggungjawab untuk berbual. Pengguna pertama perlu membuat sesi dan kemudian pada sesi itu akan digunakan untuk berbual.

export class AgentManager {
    private __lock = new Mutex();
    private __agents: Map<string, AgentInstance> = new Map();

    async createAgent(authorization: string): Promise<string> {
        const uuid = uuidv4();
        const release = await this.__lock.acquire();
        try {
            this.__deleteExpiredAgentsLockless();
            let agent: ChatAgent | null = agent = new GeneralChatAgent(authorization);
            this.__agents.set(uuid, { agent, createdAt: Date.now() });
            return uuid;
        } finally {
            release();
        }
    }

    async getAgent(uuid: string): Promise<ChatAgent | null> {
        const release = await this.__lock.acquire();
        try {
            this.__deleteExpiredAgentsLockless();
            const agentInstance = this.__agents.get(uuid);
            return agentInstance ? agentInstance.agent : null;
        } finally {
            release();
        }
    }

    private __deleteExpiredAgentsLockless(): void {}
}

Mewujudkan Ejen Am

Sekarang kita perlu mencipta ejen sembang umum, yang akan mendapat parameter dengan katakan sebagai contoh auth atau mana-mana yang anda perlukan dan boleh berkomunikasi dengan API, tetapi buat masa ini kami akan melanjutkan ChatAgent sedia ada dan tiada lagi untuk langkah ini.

export class GeneralChatAgent extends ChatAgent {
    constructor() {
        super();
    }
}

Kaedah createAgent memulakan ejen, mengunci proses dan memberikannya kepada ID sesi unik. Ejen tamat tempoh selepas tempoh sesi yang ditentukan, yang dikendalikan oleh kaedah __deleteExpiredAgentsLockless tetapi kami akan melaksanakannya dalam lelaran seterusnya anda boleh mengelakkannya buat masa ini.

Mengendalikan Sesi dan Mesej

Seterusnya, mari kita tentukan penciptaan sesi dan laluan pengendalian mesej kami:

export const createSession = async (req: Request, res: Response): Promise<void> => {
    const authorization = req.headers['authorization'] as string;
    try {
        const sessionId = await agentManager.createAgent(authorization, AgentType.WEB);
        res.json({ sessionId });
    } catch (err) {
        if (err instanceof Error) {
            res.status(400).json({ error: err.message });
        } else {
            res.status(500).json({ error: 'An unknown error occurred' });
        }
    }
}

export const postMessage = async (req: Request, res: Response): Promise<void> => {
    const { id } = req.params;
    const { message } = req.body;

    if (!id || !message) {
        return res.status(400).json({ error: 'Bad request. Missing session ID or message' });
    }

    try {
        const agent = await agentManager.getAgent(id);
        if (!agent) {
            return res.status(400).json({ error: `No agent found with id ${id}` });
        }

        const iterable = await agent.invoke(message);
        await streamResponse(res, iterable);
    } catch (err) {
        res.status(500).json({ error: err instanceof Error ? err.message : 'An unknown error occurred' });
    }
}

Di sini, createSession menyediakan sesi baharu dan postMessage menghantar mesej pengguna kepada ejen. Jika tiada sesi atau mesej disediakan, ia mengembalikan ralat 400 Permintaan Buruk.
Respons Penstriman

Kini, kunci untuk menjadikan bot sembang kami berasa responsif dan interaktif: menstrim respons.

async invoke(input: string): Promise<AsyncIterable<Chunk>> {
    const release = await this.__lock.acquire();
    try {
        const tool = this.determineTool(input);
        if (tool) {
            const toolOutput = await tool.call(input);
            this.callbackQueue.enqueue({ type: ChunkType.TOKEN, value: toolOutput });
            this.callbackQueue.enqueue({ type: ChunkType.FINISH, value: '' });
        } else {
            await this.chat.invoke([new HumanMessage(input)], {
                callbacks: [
                    {
                        handleLLMNewToken: (token: string) => {
                            this.callbackQueue.enqueue({ type: ChunkType.TOKEN, value: token });
                        },
                        handleLLMEnd: () => {
                            this.callbackQueue.enqueue({ type: ChunkType.FINISH, value: '' });
                        },
                        handleLLMError: (error: Error) => {
                            this.callbackQueue.enqueue({ type: ChunkType.ERROR, value: error.message });
                        }
                    }
                ]
            });
        }
        return this.createAsyncIterable(this.callbackQueue);
    } finally {
        release();
    }
}

private createAsyncIterable(callbackQueue: AgentCallbackQueue): AsyncIterable<Chunk> {
    return {
        [Symbol.asyncIterator]: async function* () {
            let finished = false;
            while (!finished) {
                const chunk = await callbackQueue.dequeue();
                if (chunk) {
                    yield chunk;
                    if (chunk.type === ChunkType.FINISH || chunk.type === ChunkType.ERROR) {
                        finished = true;
                    }
                } else {
                    await new Promise(resolve => setTimeout(resolve, 100));
                }
            }
        }
    };
}

Dalam kaedah invoke, ejen memproses input pengguna dan menstrim kembali respons dalam ketulan. Setiap bahagian adalah sama ada token daripada model atau mesej yang menunjukkan penghujung strim.

Kaedah createAsyncIterable membolehkan kami menjana ketulan ini satu demi satu dan menstrimnya kembali kepada pelanggan.

Sambutan penstriman

Akhirnya, kami ingin menstrim respons kepada pelanggan semasa kami menerimanya, tidak mahu menunggu beberapa lama sehingga selesai dan mengembalikan keseluruhan respons, penyelesaian yang lebih baik adalah menstrim respons dalam ketulan.

const delay = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms));

export async function streamResponse(res: Response, iterable: AsyncIterable<Chunk>) {
    res.setHeader('Content-Type', 'application/x-ndjson');
    res.setHeader('Transfer-Encoding', 'chunked');

    try {
        let buffer = '';
        for await (const chunk of iterable) {
            switch (chunk.type) {
                case ChunkType.TOKEN:
                    buffer += chunk.value; 
                    res.write(buffer);
                    if (res.flush) res.flush();
                    buffer = '';
                    break;

                case ChunkType.ERROR:
                    console.error('Error chunk:', chunk.value);
                    if (!res.headersSent) {
                        res.status(500).json({ error: 'Streaming failed.' });
                    }
                    return;

                case ChunkType.FINISH:
                    if (buffer.trim()) {
                        res.write(`${buffer.trim()}\n`);
                    }
                    return;
            }
        }
    } catch (err) {
        console.error('Error during streaming:', err);
        if (!res.headersSent) {
            res.status(500).json({ error: 'Streaming failed.' });
        }
    } finally {
        res.end();
    }
}

Kesimpulan

Tahniah! Anda kini mempunyai bot sembang asas yang mengendalikan sesi sembang dan menstrim respons kembali kepada pelanggan. Seni bina ini boleh diperluaskan dengan mudah dengan alatan tambahan, logik yang lebih canggih atau model GPT yang berbeza, tetapi buat masa ini kami mempunyai rangka untuk chatbot yang lebih kompleks.

Dengan menggunakan model bahasa OpenAI yang berkuasa dan pengurusan alat LangChain, anda boleh mencipta chatbot yang lebih maju dan interaktif untuk pelbagai domain. Anda boleh mengembangkan keupayaan chatbots dan membuatnya mengikut cara yang anda mahukan tetapi sebaliknya anda tidak perlu gunakan Langchain , anda boleh menggunakan OpenAI dan buat bot sembang yang lebih mudah jika anda lebih suka cara itu.

Nantikan lebih lanjut, dalam siaran seterusnya kami akan bercakap tentang membina alat untuk ejen sembang yang kami buat
Selamat mengekod!

Sila semak siaran asal

Erstellen Sie einen leistungsstarken Chatbot mit OpenAI und LangChain

In diesem Beitrag erfahren Sie, wie Sie mithilfe von OpenAI und LangChain einen einfachen, aber leistungsstarken Chatbot erstellen

bojanjagetic.com

Atas ialah kandungan terperinci Membina Chatbot Berkuasa dengan OpenAI dan LangChain. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!