Ollama LLM மற்றும் தனிப்பயன் கருவி மூலம் Langchain.js இன் ToolCallingAgentOutputParser பிழையை சரிசெய்தல்

Langchain.js இல் ToolCallingAgentOutputParser பிழைகளைப் புரிந்துகொண்டு சரிசெய்தல்

Langchain.js v2 உடன் பணிபுரியும் போது, ​​டெவலப்பர்கள் தனிப்பயன் கருவிகள் மற்றும் Ollama போன்ற மொழி மாதிரிகளைப் பயன்படுத்தி திறமையான முகவர்களை உருவாக்குவதை நோக்கமாகக் கொண்டுள்ளனர். இருப்பினும், இந்த கூறுகளை ஒருங்கிணைப்பது சில நேரங்களில் பிழைகளை சரிசெய்ய கடினமாக இருக்கும்.

அத்தகைய ஒரு பிழையானது "ToolCallingAgentOutputParser இல் உள்ள parseResult ChatGeneration வெளியீட்டில் மட்டுமே வேலை செய்யும்", இது முகவர் கட்டமைப்பிற்குள் தனிப்பயன் கருவியை உருவாக்கும்போது ஏற்படும். முகவர் மற்றும் கருவி சரியாக வேலை செய்வதை உறுதி செய்ய, இந்த சிக்கலின் மூல காரணத்தை புரிந்துகொள்வது முக்கியம்.

Langchain இன் createToolCallingAgent மற்றும் Ollama மாதிரியைப் பயன்படுத்தி, எண்ணை உள்ளீட்டில் 2ஐ சேர்க்கும் தனிப்பயன் கருவியின் எளிய செயலாக்கத்தை இந்தக் கட்டுரை ஆராய்கிறது. பிழை மற்றும் அதன் சூழலை பகுப்பாய்வு செய்வதன் மூலம், அதை எவ்வாறு சரிசெய்வது என்பதை நாம் நன்கு புரிந்து கொள்ள முடியும்.

பின்வரும் பிரிவுகள் குறியீட்டின் மூலம் உங்களுக்கு வழிகாட்டும், பிழையை விளக்கும் மற்றும் இந்த சிக்கலைத் தீர்ப்பதற்கான தீர்வுகளை வழங்கும். நீங்கள் Langchain.js க்கு புதியவராக இருந்தாலும் சரி அல்லது அனுபவம் வாய்ந்தவராக இருந்தாலும் சரி, இந்தச் சிக்கலைத் திறம்பட கடந்து செல்ல இந்த வழிகாட்டி உதவும்.

Langchain.js இல் தனிப்பயன் கருவி மற்றும் முகவர் பிழை கையாளுதல் ஆகியவற்றைப் புரிந்துகொள்வது

வழங்கப்பட்ட எடுத்துக்காட்டில், Langchain.js v2 உடன் இணைந்து ஒரு தனிப்பயன் கருவியை உருவாக்க நாங்கள் வேலை செய்கிறோம். ஒல்லமா மொழி மாதிரி. கருவியின் முக்கிய நோக்கம் ஒரு எளிய கணித செயல்பாட்டைச் செய்வதாகும்: உள்ளீட்டு மதிப்பில் 2 ஐச் சேர்த்தல். கருவி லாங்செயினைப் பயன்படுத்தி உருவாக்கப்பட்டுள்ளது கருவி செயல்பாடு, இது ஒரு முகவரால் செயல்படுத்தப்படக்கூடிய மறுபயன்பாட்டு செயல்பாடுகளை வரையறுக்கிறது. கருவி சரியாகச் செயல்படுவதை உறுதிசெய்ய, உள்ளீட்டுத் திட்டம் Zod நூலகத்தில் சரிபார்க்கப்பட்டு, உள்ளீடு செல்லுபடியாகும் எண் என்பதை உறுதிப்படுத்துகிறது. இது சரியான பிழை கையாளுதலை உறுதி செய்கிறது மற்றும் தவறான உள்ளீடுகளால் கருவி தோல்வியடைவதைத் தடுக்கிறது.

தனிப்பயன் கருவி பின்னர் ஒரு முகவருடன் இணைக்கப்பட்டது createToolCallingAgent செயல்பாடு. இந்தக் கட்டளையானது, கருவியை தேவைப்படும்போது அழைக்க ஏஜென்ட்டை அனுமதிக்கிறது, மேலும் பதில்களின் படைப்பாற்றலைக் கட்டுப்படுத்த வெப்பநிலை போன்ற குறிப்பிட்ட அளவுருக்களுடன் உள்ளமைக்கப்பட்ட ஒல்லாமா மாதிரி மூலம் முகவர் இயக்கப்படுகிறது. முகவருக்கும் கருவிக்கும் இடையே சுமூகமான தொடர்புகளை எளிதாக்க, அரட்டை ப்ராம்ட் டெம்ப்ளேட் பயன்படுத்தப்படுகிறது. இந்த டெம்ப்ளேட், சிஸ்டம் செய்திகள், மனித உள்ளீடு மற்றும் பிளேஸ்ஹோல்டர்கள் போன்ற பல்வேறு வகையான செய்திகளை வரையறுத்து உரையாடலை ஒழுங்கமைக்கிறது. போன்ற இடங்கள் MessagesPlaceholder, அரட்டை வரலாறு போன்ற கூறுகளுடன் உரையாடலை டைனமிக் ஆக அனுமதிக்கவும்.

இந்த எடுத்துக்காட்டில் குறிப்பிடப்பட்ட முக்கிய சிக்கல்களில் ஒன்று, லாங்செயின் ஏஜெண்டின் அவுட்புட் பாகுபடுத்தலில் உள்ள பிழை கையாளுதல் ஆகும். "ParseResult on ToolCallingAgentOutputParser ChatGeneration வெளியீட்டில் மட்டுமே இயங்குகிறது" என்ற பிழை செய்தியானது, பாகுபடுத்தி எதிர்பார்க்கும் வெளியீட்டின் வகைக்கும் உருவாக்கப்பட்ட உண்மையான வெளியீட்டிற்கும் இடையே உள்ள பொருத்தமின்மையால் ஏற்படுகிறது. இந்த பிழையைக் கையாள, தனிப்பயன் கருவி வலுவான தர்க்கத்தில் மூடப்பட்டிருக்கும், அனைத்து உள்ளீடுகளும் வெளியீடுகளும் எதிர்பார்க்கப்படும் வடிவங்களுக்கு இணங்குவதை உறுதி செய்கிறது. இது மேலும் நிர்வகிக்கப்படுகிறது முகவர் நிறைவேற்றுபவர் கிளாஸ், இது முகவர் மற்றும் கருவிகளின் செயல்பாட்டை ஒருங்கிணைக்கிறது, வினவல் மற்றும் கருவி வெளியீடு சரியாக ஒத்திசைக்கப்பட்டுள்ளதா என்பதை உறுதிப்படுத்துகிறது.

இறுதியாக, ஸ்கிரிப்டுகள் ஒத்திசைவற்ற செயலாக்கத்தைப் பயன்படுத்தி செயல்படுத்துகின்றன காத்திருங்கள், மற்ற செயல்முறைகளைத் தடுக்காமல் செயல்பாடுகளைக் கையாள கணினியை அனுமதிக்கிறது. தொடர்வதற்கு முன் கருவி அதன் முடிவைத் தரும் வரை முகவர் காத்திருக்கிறார், பதில் துல்லியமாகவும் சரியான நேரத்திலும் இருப்பதை உறுதிசெய்கிறார். கூடுதலாக, கருவியின் செயல்பாட்டை சரிபார்க்க அலகு சோதனைகள் சேர்க்கப்பட்டுள்ளன, இது தொடர்ந்து சரியான வெளியீட்டை உருவாக்குகிறது. இந்தச் சோதனைகள் கருவியின் கணிதச் செயல்பாட்டை உறுதிப்படுத்துவது மட்டுமல்லாமல், அது தவறான உள்ளீட்டை எவ்வளவு சிறப்பாகக் கையாளுகிறது என்பதையும் சரிபார்த்து, தீர்வின் ஒட்டுமொத்த நம்பகத்தன்மையை மேம்படுத்துகிறது. இந்த மட்டு மற்றும் பிழை-எதிர்ப்பு வடிவமைப்பு 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 மற்றும் Ollama LLM ஒருங்கிணைப்பில் முகவர்களின் பங்கை ஆராய்தல்

Langchain.js உடன் பணிபுரியும் போது, ​​ஒருங்கிணைக்கிறது முகவர்கள் ஒல்லாமா போன்ற கருவிகள் மற்றும் மொழி மாதிரிகள் மாறும் பயன்பாடுகளை உருவாக்குவதற்கான முக்கியமான அம்சமாகும். குறிப்பிட்ட பணிகளைச் செய்யும் தனிப்பயன் கருவியை, அதிக உரையாடல் அல்லது உருவாக்கும் பணிகளைக் கையாளும் மொழி மாதிரியுடன் இணைக்க முகவர் உங்களை அனுமதிக்கிறது. முகவர்களைப் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் பணிப்பாய்வுகளை தானியக்கமாக்க முடியும், அங்கு ஒரு மாதிரி பதில்களை உருவாக்குவது மட்டுமல்லாமல் கணக்கீடுகள் அல்லது தரவு செயலாக்கத்தைச் செய்வதற்கான கருவிகளையும் செயல்படுத்துகிறது.

இந்த ஒருங்கிணைப்பின் முக்கிய அங்கம் createToolCallingAgent செயல்பாடு. இந்தச் செயல்பாடு, தேவைப்படும்போது குறிப்பிட்ட கருவிகளைத் தூண்டுவதற்கு முகவரை அனுமதிக்கிறது, மேலும் பணிகள் துல்லியமாகவும் திறமையாகவும் முடிக்கப்படுவதை உறுதி செய்கிறது. கருவியை உருவாக்குவதிலேயே முதன்மை கவனம் பெரும்பாலும் இருக்கும் போது, ​​முகவரின் பணிப்பாய்வுகளை எவ்வாறு நிர்வகிப்பது மற்றும் பாகுபடுத்தும் பிழைகளைத் தவிர்ப்பது எப்படி என்பதைப் புரிந்துகொள்வது சமமாக முக்கியமானது. "ParseResult on ToolCallingAgentOutputParser ChatGeneration வெளியீட்டில் மட்டுமே இயங்குகிறது" போன்ற பிழைகள் பொதுவாக ஏஜென்ட்டின் வெளியீடு பாகுபடுத்தும் முறையுடன் ஒத்துப்போகவில்லை, ஏஜென்ட்டின் வெளியீடு மற்றும் எதிர்பார்க்கப்படும் வடிவமைப்பிற்கு இடையே சரியான சீரமைப்பின் அவசியத்தை எடுத்துக்காட்டுகிறது.

போன்ற உடனடி வார்ப்புருக்களின் பயன்பாடு ChatPrompt டெம்ப்ளேட், டைனமிக் செய்திகள் மற்றும் சூழல் பிளேஸ்ஹோல்டர்களை அனுமதிப்பதன் மூலம் தொடர்புகளை மேலும் மேம்படுத்துகிறது. அரட்டை வரலாறு அல்லது ஏஜெண்டின் ஸ்க்ராட்ச்பேட் ஆகியவற்றின் அடிப்படையில் ஏஜென்ட் தனது பதில்களைச் சரிசெய்ய இது அனுமதிக்கிறது. உடனடி டெம்ப்ளேட்களை மேம்படுத்துதல் மற்றும் முகவரின் வெளியீடுகள் சரியாகப் பாகுபடுத்தப்படுவதை உறுதிசெய்தல், உங்கள் Langchain.js பயன்பாடுகளை மிகவும் நம்பகமானதாகவும் திறமையானதாகவும் மாற்றும் பல பொதுவான பிழைகளைத் தடுக்கலாம்.