ਓਲਾਮਾ LLM ਅਤੇ ਇੱਕ ਕਸਟਮ ਟੂਲ ਨਾਲ Langchain.js ਦੀ ToolCallingAgentOutputParser ਗਲਤੀ ਨੂੰ ਠੀਕ ਕਰਨਾ

Langchain.js ਵਿੱਚ ToolCallingAgentOutputParser ਗਲਤੀਆਂ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਠੀਕ ਕਰਨਾ

Langchain.js v2 ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਡਿਵੈਲਪਰ ਅਕਸਰ ਓਲਾਮਾ ਵਰਗੇ ਕਸਟਮ ਟੂਲਸ ਅਤੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੁਸ਼ਲ ਏਜੰਟ ਬਣਾਉਣ ਦਾ ਟੀਚਾ ਰੱਖਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਇਹਨਾਂ ਭਾਗਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਨਾਲ ਕਈ ਵਾਰ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੁੰਦਾ ਹੈ।

ਅਜਿਹੀ ਇੱਕ ਗਲਤੀ ਹੈ "ਟੂਲਕਾਲਿੰਗ ਏਜੇਂਟ ਆਉਟਪੁਟ ਪਾਰਸਰ 'ਤੇ ਪਾਰਸ ਰਿਜ਼ਲਟ ਸਿਰਫ ਚੈਟਜਨਰੇਸ਼ਨ ਆਉਟਪੁੱਟ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ," ਜੋ ਕਿ ਏਜੰਟ ਫਰੇਮਵਰਕ ਦੇ ਅੰਦਰ ਇੱਕ ਕਸਟਮ ਟੂਲ ਬਣਾਉਣ ਵੇਲੇ ਹੋ ਸਕਦੀ ਹੈ। ਏਜੰਟ ਅਤੇ ਟੂਲ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਮੁੱਦੇ ਦੇ ਮੂਲ ਕਾਰਨ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਇਹ ਲੇਖ ਇੱਕ ਕਸਟਮ ਟੂਲ ਦੇ ਇੱਕ ਸਧਾਰਨ ਲਾਗੂਕਰਨ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ ਜੋ ਲੈਂਗਚੈਨ ਦੇ createToolCallingAgent ਅਤੇ ਓਲਾਮਾ ਮਾਡਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇੱਕ ਨੰਬਰ ਇਨਪੁਟ ਵਿੱਚ 2 ਜੋੜਦਾ ਹੈ। ਗਲਤੀ ਅਤੇ ਇਸਦੇ ਸੰਦਰਭ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦੁਆਰਾ, ਅਸੀਂ ਇਸਨੂੰ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਸਮਝ ਸਕਦੇ ਹਾਂ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਨਿਪਟਾਉਣਾ ਹੈ।

ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗ ਤੁਹਾਨੂੰ ਕੋਡ ਦੁਆਰਾ ਮਾਰਗਦਰਸ਼ਨ ਕਰਨਗੇ, ਗਲਤੀ ਦੀ ਵਿਆਖਿਆ ਕਰਨਗੇ, ਅਤੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਹੱਲ ਪ੍ਰਦਾਨ ਕਰਨਗੇ। ਭਾਵੇਂ ਤੁਸੀਂ Langchain.js ਲਈ ਨਵੇਂ ਹੋ ਜਾਂ ਅਨੁਭਵੀ ਹੋ, ਇਹ ਗਾਈਡ ਤੁਹਾਨੂੰ ਇਸ ਮੁੱਦੇ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪਾਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗੀ।

Langchain.js ਵਿੱਚ ਕਸਟਮ ਟੂਲ ਅਤੇ ਏਜੰਟ ਐਰਰ ਹੈਂਡਲਿੰਗ ਨੂੰ ਸਮਝਣਾ

ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਕਸਟਮ ਟੂਲ ਬਣਾਉਣ ਲਈ Langchain.js v2 ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ ਜੋ ਇਸ ਨਾਲ ਏਕੀਕ੍ਰਿਤ ਹੁੰਦਾ ਹੈ ਓਲਾਮਾ ਭਾਸ਼ਾ ਮਾਡਲ. ਟੂਲ ਦਾ ਮੁੱਖ ਉਦੇਸ਼ ਇੱਕ ਸਧਾਰਨ ਗਣਿਤਿਕ ਕਾਰਵਾਈ ਕਰਨਾ ਹੈ: ਇਨਪੁਟ ਮੁੱਲ ਵਿੱਚ 2 ਜੋੜਨਾ। ਟੂਲ ਲੈਂਗਚੈਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਗਿਆ ਹੈ ਸੰਦ ਹੈ ਫੰਕਸ਼ਨ, ਜੋ ਕਿ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ ਏਜੰਟ ਦੁਆਰਾ ਬੁਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਟੂਲ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਨਪੁਟ ਸਕੀਮਾ ਨੂੰ Zod ਲਾਇਬ੍ਰੇਰੀ ਨਾਲ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਇਹ ਗਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਇਨਪੁਟ ਇੱਕ ਵੈਧ ਨੰਬਰ ਹੈ। ਇਹ ਸਹੀ ਤਰੁੱਟੀ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਅਵੈਧ ਇਨਪੁਟਸ ਦੇ ਕਾਰਨ ਟੂਲ ਨੂੰ ਅਸਫਲ ਹੋਣ ਤੋਂ ਰੋਕਦਾ ਹੈ।

ਕਸਟਮ ਟੂਲ ਨੂੰ ਫਿਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਏਜੰਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ createToolCallingAgent ਫੰਕਸ਼ਨ. ਇਹ ਕਮਾਂਡ ਏਜੰਟ ਨੂੰ ਲੋੜ ਪੈਣ 'ਤੇ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਏਜੰਟ ਨੂੰ ਓਲਾਮਾ ਮਾਡਲ ਦੁਆਰਾ ਸੰਚਾਲਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਜਵਾਬਾਂ ਦੀ ਰਚਨਾਤਮਕਤਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਤਾਪਮਾਨ ਵਰਗੇ ਖਾਸ ਮਾਪਦੰਡਾਂ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਏਜੰਟ ਅਤੇ ਟੂਲ ਦੇ ਵਿਚਕਾਰ ਨਿਰਵਿਘਨ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਦੀ ਸਹੂਲਤ ਲਈ, ਇੱਕ ਚੈਟ ਪ੍ਰੋਂਪਟ ਟੈਂਪਲੇਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਟੈਮਪਲੇਟ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਸੁਨੇਹਿਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਗੱਲਬਾਤ ਨੂੰ ਸੰਗਠਿਤ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਸਿਸਟਮ ਸੰਦੇਸ਼, ਮਨੁੱਖੀ ਇਨਪੁਟ, ਅਤੇ ਪਲੇਸਹੋਲਡਰ। ਸਥਾਨਧਾਰਕ, ਜਿਵੇਂ ਕਿ ਸੁਨੇਹੇ ਪਲੇਸਹੋਲਡਰ, ਗੱਲਬਾਤ ਨੂੰ ਗਤੀਸ਼ੀਲ ਹੋਣ ਦਿਓ, ਜਿਸ ਵਿੱਚ ਚੈਟ ਇਤਿਹਾਸ ਵਰਗੇ ਤੱਤ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾ ਰਹੇ ਹਨ।

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਸੰਬੋਧਿਤ ਕੀਤੇ ਗਏ ਮੁੱਖ ਮੁੱਦਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਲੈਂਗਚੈਨ ਏਜੰਟ ਦੇ ਆਉਟਪੁੱਟ ਪਾਰਸਿੰਗ ਦੇ ਆਲੇ ਦੁਆਲੇ ਗਲਤੀ ਨਾਲ ਨਜਿੱਠਣਾ। ਤਰੁਟੀ ਸੁਨੇਹਾ "ਟੂਲਕਾਲਿੰਗ ਏਜੇਂਟ ਆਉਟਪੁਟ ਪਾਰਸਰ 'ਤੇ ਪਾਰਸ ਰਿਜ਼ਲਟ ਸਿਰਫ ਚੈਟ ਜਨਰੇਸ਼ਨ ਆਉਟਪੁੱਟ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ" ਪਾਰਸਰ ਦੁਆਰਾ ਉਮੀਦ ਕੀਤੀ ਗਈ ਆਉਟਪੁੱਟ ਦੀ ਕਿਸਮ ਅਤੇ ਉਤਪੰਨ ਅਸਲ ਆਉਟਪੁੱਟ ਵਿਚਕਾਰ ਇੱਕ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੈ। ਇਸ ਗਲਤੀ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਕਸਟਮ ਟੂਲ ਨੂੰ ਮਜ਼ਬੂਤ ​​ਤਰਕ ਵਿੱਚ ਲਪੇਟਿਆ ਗਿਆ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਸਾਰੇ ਇਨਪੁਟਸ ਅਤੇ ਆਉਟਪੁੱਟ ਉਮੀਦ ਕੀਤੇ ਫਾਰਮੈਟਾਂ ਦੇ ਅਨੁਕੂਲ ਹਨ। ਇਸ ਦਾ ਪ੍ਰਬੰਧਨ ਹੋਰਾਂ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਏਜੰਟ ਐਗਜ਼ੀਕਿਊਟਰ ਕਲਾਸ, ਜੋ ਕਿ ਏਜੰਟ ਅਤੇ ਟੂਲਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਤਾਲਮੇਲ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪੁੱਛਗਿੱਛ ਅਤੇ ਟੂਲ ਆਉਟਪੁੱਟ ਸਹੀ ਢੰਗ ਨਾਲ ਸਮਕਾਲੀ ਹਨ।

ਅੰਤ ਵਿੱਚ, ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਸਿੰਕਰੋਨਸ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਉਡੀਕ ਕਰੋ, ਸਿਸਟਮ ਨੂੰ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਬਲੌਕ ਕੀਤੇ ਬਿਨਾਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਏਜੰਟ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਟੂਲ ਦੇ ਨਤੀਜੇ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਜਵਾਬ ਸਹੀ ਅਤੇ ਸਮੇਂ ਸਿਰ ਹੋਵੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟੂਲ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਇਹ ਲਗਾਤਾਰ ਸਹੀ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇਹ ਟੈਸਟ ਨਾ ਸਿਰਫ਼ ਟੂਲ ਦੇ ਗਣਿਤਿਕ ਸੰਚਾਲਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦੇ ਹਨ ਬਲਕਿ ਇਹ ਵੀ ਜਾਂਚਦੇ ਹਨ ਕਿ ਇਹ ਅਵੈਧ ਇਨਪੁਟ ਨੂੰ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲਦਾ ਹੈ, ਹੱਲ ਦੀ ਸਮੁੱਚੀ ਭਰੋਸੇਯੋਗਤਾ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਮਾਡਿਊਲਰ ਅਤੇ ਗਲਤੀ-ਰੋਧਕ ਡਿਜ਼ਾਈਨ Langchain.js ਦੇ ਅੰਦਰ ਵੱਖ-ਵੱਖ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਬਣਾਉਂਦਾ ਹੈ।

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { Ollama } from "@langchain/ollama";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { createToolCallingAgent } from "langchain/agents";
import { AgentExecutor } from "langchain/agents";
// Initialize LLM with Ollama
const llm = new Ollama({
    model: "llama3",
    temperature: 0.7,
});
// Custom tool to add 2 to the input number
const magicTool = tool(
    async (input) => {
        return input + 2;
    },
    {
        name: "magic_function",
        description: "Applies a magic function to an input",
        schema: z.object({ input: z.number() }),
    };
);
const tools = [magicTool];
// Setup ChatPromptTemplate with placeholders
const prompt = ChatPromptTemplate.fromMessages([
    ["system", "You are a helpful assistant called iHelp"],
    ["placeholder", "{chat_history}"],
    ["human", "{input}"],
    ["placeholder", "{agent_scratchpad}"],
]);
// Agent configuration
const agent = createToolCallingAgent({ llm, tools, prompt });
// Execute agent query
const agentExecutor = new AgentExecutor({ agent, tools });
const query = "What is the value of magic_function(3)?";
await agentExecutor.invoke({ input: query });

import { tool } from "@langchain/core/tools";
import { z } from "zod";
import { Ollama } from "@langchain/ollama";
import { createToolCallingAgent } from "langchain/agents";
import { AgentExecutor } from "langchain/agents";
// Initialize LLM with Ollama
const llm = new Ollama({ model: "llama3", temperature: 0.7 });
// Custom tool with added error handling
const magicTool = tool(
    async (input) => {
        try {
            if (typeof input !== "number") throw new Error("Invalid input type!");
            return input + 2;
        } catch (err) {
            return err.message;
        }
    },
    {
        name: "magic_function",
        description: "Adds 2 to input and handles errors",
        schema: z.object({ input: z.number() }),
    }
);
const tools = [magicTool];
// Agent and execution
const agent = createToolCallingAgent({ llm, tools });
const agentExecutor = new AgentExecutor({ agent, tools });
const query = "magic_function('abc')"; // Test with invalid input
await agentExecutor.invoke({ input: query });
// Unit test example
import { expect } from "chai";
it("should return 5 when input is 3", async () => {
    const result = await magicTool(3);
    expect(result).to.equal(5);
});

Langchain.js ਅਤੇ ਓਲਾਮਾ LLM ਏਕੀਕਰਣ ਵਿੱਚ ਏਜੰਟਾਂ ਦੀ ਭੂਮਿਕਾ ਦੀ ਪੜਚੋਲ ਕਰਨਾ

Langchain.js ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਏਜੰਟ ਓਲਾਮਾ ਵਰਗੇ ਟੂਲਸ ਅਤੇ ਭਾਸ਼ਾ ਮਾਡਲਾਂ ਦੇ ਨਾਲ ਗਤੀਸ਼ੀਲ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ। ਇੱਕ ਏਜੰਟ ਤੁਹਾਨੂੰ ਇੱਕ ਕਸਟਮ ਟੂਲ, ਜੋ ਕਿ ਖਾਸ ਕੰਮ ਕਰਦਾ ਹੈ, ਨੂੰ ਇੱਕ ਭਾਸ਼ਾ ਮਾਡਲ ਨਾਲ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜੋ ਵਧੇਰੇ ਗੱਲਬਾਤ ਜਾਂ ਉਤਪੰਨ ਕਾਰਜਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ। ਏਜੰਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਡਿਵੈਲਪਰ ਵਰਕਫਲੋ ਨੂੰ ਸਵੈਚਲਿਤ ਕਰ ਸਕਦੇ ਹਨ ਜਿੱਥੇ ਇੱਕ ਮਾਡਲ ਨਾ ਸਿਰਫ਼ ਜਵਾਬ ਪੈਦਾ ਕਰਦਾ ਹੈ ਬਲਕਿ ਗਣਨਾਵਾਂ ਜਾਂ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਕਰਨ ਲਈ ਟੂਲਜ਼ ਦੀ ਮੰਗ ਵੀ ਕਰਦਾ ਹੈ।

ਇਸ ਏਕੀਕਰਣ ਵਿੱਚ ਮੁੱਖ ਭਾਗ ਹੈ createToolCallingAgent ਫੰਕਸ਼ਨ. ਇਹ ਫੰਕਸ਼ਨ ਏਜੰਟ ਨੂੰ ਲੋੜ ਪੈਣ 'ਤੇ ਖਾਸ ਟੂਲ ਸ਼ੁਰੂ ਕਰਨ ਦਿੰਦਾ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਕੰਮ ਸਹੀ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪੂਰੇ ਕੀਤੇ ਗਏ ਹਨ। ਜਦੋਂ ਕਿ ਪ੍ਰਾਇਮਰੀ ਫੋਕਸ ਅਕਸਰ ਟੂਲ ਨੂੰ ਖੁਦ ਬਣਾਉਣ 'ਤੇ ਹੁੰਦਾ ਹੈ, ਇਹ ਸਮਝਣਾ ਕਿ ਏਜੰਟ ਦੇ ਵਰਕਫਲੋ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਹੈ ਅਤੇ ਪਾਰਸਿੰਗ ਗਲਤੀਆਂ ਤੋਂ ਬਚਣਾ ਵੀ ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਹੈ। "ToolCallingAgentOutputParser 'ਤੇ parseResult ਸਿਰਫ਼ ChatGeneration ਆਉਟਪੁੱਟ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ" ਵਰਗੀਆਂ ਤਰੁੱਟੀਆਂ ਆਮ ਤੌਰ 'ਤੇ ਉਦੋਂ ਵਾਪਰਦੀਆਂ ਹਨ ਜਦੋਂ ਏਜੰਟ ਦਾ ਆਉਟਪੁੱਟ ਪਾਰਸਿੰਗ ਸਿਸਟਮ ਦੇ ਅਨੁਕੂਲ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਏਜੰਟ ਦੇ ਆਉਟਪੁੱਟ ਅਤੇ ਸੰਭਾਵਿਤ ਫਾਰਮੈਟ ਵਿਚਕਾਰ ਸਹੀ ਅਲਾਈਨਮੈਂਟ ਦੀ ਲੋੜ ਨੂੰ ਉਜਾਗਰ ਕਰਦਾ ਹੈ।

ਪ੍ਰੋਂਪਟ ਟੈਂਪਲੇਟਸ ਦੀ ਵਰਤੋਂ, ਜਿਵੇਂ ਕਿ ChatPromptTemplate, ਗਤੀਸ਼ੀਲ ਸੁਨੇਹਿਆਂ ਅਤੇ ਸੰਦਰਭ ਪਲੇਸਹੋਲਡਰਾਂ ਦੀ ਆਗਿਆ ਦੇ ਕੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਹੋਰ ਅਮੀਰ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਏਜੰਟ ਨੂੰ ਚੈਟ ਇਤਿਹਾਸ ਜਾਂ ਏਜੰਟ ਦੇ ਸਕ੍ਰੈਚਪੈਡ ਦੇ ਆਧਾਰ 'ਤੇ ਆਪਣੇ ਜਵਾਬਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਪ੍ਰੋਂਪਟ ਟੈਂਪਲੇਟਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਅਤੇ ਏਜੰਟ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪਾਰਸ ਕਰਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣਾ ਬਹੁਤ ਸਾਰੀਆਂ ਆਮ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕ ਸਕਦਾ ਹੈ, ਤੁਹਾਡੀਆਂ Langchain.js ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਵਧੇਰੇ ਭਰੋਸੇਮੰਦ ਅਤੇ ਕੁਸ਼ਲ ਬਣਾਉਂਦਾ ਹੈ।