Langchain.jsలో ToolCallingAgentOutputParser లోపాలను అర్థం చేసుకోవడం మరియు పరిష్కరించడం
Langchain.js v2తో పని చేస్తున్నప్పుడు, డెవలపర్లు తరచుగా కస్టమ్ టూల్స్ మరియు ఒల్లామా వంటి భాషా నమూనాలను ఉపయోగించి సమర్థవంతమైన ఏజెంట్లను సృష్టించాలని లక్ష్యంగా పెట్టుకుంటారు. అయినప్పటికీ, ఈ భాగాలను ఏకీకృతం చేయడం వలన కొన్నిసార్లు డీబగ్ చేయడం కష్టంగా ఉండే లోపాలకు దారితీయవచ్చు.
అటువంటి లోపం ఏమిటంటే, "ToolCallingAgentOutputParserలోని parseResult ChatGeneration అవుట్పుట్లో మాత్రమే పని చేస్తుంది," ఇది ఏజెంట్ ఫ్రేమ్వర్క్లో అనుకూల సాధనాన్ని రూపొందించేటప్పుడు సంభవించవచ్చు. ఏజెంట్ మరియు టూల్ సరిగ్గా పని చేస్తున్నాయని నిర్ధారించడానికి ఈ సమస్య యొక్క మూల కారణాన్ని అర్థం చేసుకోవడం చాలా ముఖ్యం.
ఈ కథనం Langchain యొక్క createToolCallingAgent మరియు Ollama మోడల్ని ఉపయోగించి సంఖ్య ఇన్పుట్కు 2ని జోడించే అనుకూల సాధనం యొక్క సరళమైన అమలును అన్వేషిస్తుంది. లోపాన్ని మరియు దాని సందర్భాన్ని విశ్లేషించడం ద్వారా, దాన్ని ఎలా పరిష్కరించాలో మనం బాగా గ్రహించవచ్చు.
కింది విభాగాలు మీకు కోడ్ ద్వారా మార్గనిర్దేశం చేస్తాయి, లోపాన్ని వివరిస్తాయి మరియు ఈ సమస్యను పరిష్కరించడానికి పరిష్కారాలను అందిస్తాయి. మీరు Langchain.jsకి కొత్తవారైనా లేదా అనుభవం ఉన్నవారైనా, ఈ గైడ్ ఈ సమస్యను సమర్థవంతంగా అధిగమించడంలో మీకు సహాయం చేస్తుంది.
| ఆదేశం | ఉపయోగం యొక్క ఉదాహరణ |
|---|---|
| tool() | Langchain.js నుండి ఈ ఫంక్షన్ ఒక ఆపరేషన్ చేసే అనుకూల సాధనాన్ని నిర్వచిస్తుంది. ఈ ఆర్టికల్లో, ఇన్పుట్ నంబర్కు 2ని జోడించే సాధనాన్ని రూపొందించడానికి ఇది ఉపయోగించబడుతుంది, తర్కాన్ని సులభంగా కాల్ చేయగల నిర్మాణంలో చుట్టడం. |
| z.object() | జోడ్ లైబ్రరీలో ఒక భాగం, లాంగ్చెయిన్లో స్కీమా ధ్రువీకరణ కోసం ఉపయోగించబడుతుంది. ఇది కస్టమ్ సాధనానికి ఇన్పుట్ సంఖ్య అని నిర్ధారిస్తుంది, అమలు సమయంలో లోపాలను నివారించడానికి బలమైన ఇన్పుట్ ధ్రువీకరణను అందిస్తుంది. |
| createToolCallingAgent() | ఈ ఆదేశం వినియోగదారు ప్రశ్నలకు ప్రతిస్పందనగా నిర్వచించబడిన సాధనాలను కాల్ చేయగల ఏజెంట్ను సృష్టిస్తుంది. ఒల్లామా వంటి భాషా నమూనాలతో సాధనాలను ఏకీకృతం చేయడం కీలకం, సంభాషణ సమయంలో సాధనాలను ప్రారంభించడం సాధ్యమవుతుంది. |
| ChatPromptTemplate.fromMessages() | ప్లేస్హోల్డర్లతో చాట్ ప్రాంప్ట్ టెంప్లేట్ను రూపొందించడానికి ఉపయోగించబడుతుంది. ఈ టెంప్లేట్ ఏజెంట్ ఉపయోగించడానికి వివిధ రకాల సందేశాలను (సిస్టమ్, హ్యూమన్, ప్లేస్హోల్డర్లు) నిర్వహిస్తుంది, దాని సంభాషణ ప్రవాహాన్ని మెరుగుపరుస్తుంది. |
| MessagesPlaceholder | చాట్ చరిత్ర లేదా ఏజెంట్ స్క్రాచ్ప్యాడ్ వంటి డైనమిక్ కంటెంట్ కోసం ప్రాంప్ట్ టెంప్లేట్లో ప్లేస్హోల్డర్గా పనిచేస్తుంది. ఇది ఎగ్జిక్యూషన్ సమయంలో సంభాషణ సందర్భాన్ని డైనమిక్గా ఇంజెక్ట్ చేయడానికి అనుమతిస్తుంది. |
| AgentExecutor() | ఈ తరగతి ఏజెంట్లు మరియు సాధనాల అమలును నిర్వహిస్తుంది. ఉదాహరణలో, ఇది ఏజెంట్ ద్వారా ప్రశ్నను అమలు చేయడంలో మరియు సాధనం యొక్క అవుట్పుట్ నుండి ఫలితాన్ని సేకరించడంలో సహాయపడుతుంది. |
| await agentExecutor.invoke() | ఏజెంట్ ద్వారా ప్రశ్నను అమలు చేయడానికి మరియు అసమకాలిక ఫలితం కోసం వేచి ఉండటానికి ఉపయోగించబడుతుంది. భాషా నమూనాలు మరియు సాధనాలతో పరస్పర చర్య చేయడానికి ఇది చాలా కీలకం, ఎందుకంటే కొనసాగే ముందు ఆపరేషన్ పూర్తయ్యే వరకు కోడ్ వేచి ఉండేలా చేస్తుంది. |
| try-catch | చెల్లని ఇన్పుట్ రకాలను క్యాచ్ చేయడానికి అనుకూల సాధనంలో ఈ ఎర్రర్-హ్యాండ్లింగ్ నిర్మాణం ఉపయోగించబడుతుంది. మినహాయింపులను క్యాచ్ చేయడం ద్వారా, ఎగ్జిక్యూషన్ ఫ్లోను విచ్ఛిన్నం చేయకుండా సిస్టమ్ సహాయక ఎర్రర్ సందేశాలను అందజేస్తుందని ఇది నిర్ధారిస్తుంది. |
| expect() | Chai నిర్ధారిత లైబ్రరీ నుండి, కస్టమ్ టూల్ అవుట్పుట్ను ధృవీకరించడానికి యూనిట్ పరీక్షలో expect() ఉపయోగించబడుతుంది. సాధనం ఆశించిన విధంగా పనిచేస్తుందో లేదో పరీక్షించడానికి ఇది చాలా అవసరం. |
Langchain.jsలో కస్టమ్ టూల్ మరియు ఏజెంట్ ఎర్రర్ హ్యాండ్లింగ్ను అర్థం చేసుకోవడం
అందించిన ఉదాహరణలో, మేము Langchain.js v2తో కలిసి కస్టమ్ సాధనాన్ని రూపొందించడానికి పని చేస్తున్నాము. భాషా నమూనా. సాధనం యొక్క ముఖ్య ఉద్దేశ్యం ఒక సాధారణ గణిత శాస్త్ర చర్యను నిర్వహించడం: ఇన్పుట్ విలువకు 2 జోడించడం. సాధనం లాంగ్చెయిన్లను ఉపయోగించి నిర్మించబడింది ఫంక్షన్, ఇది ఏజెంట్ ద్వారా ప్రారంభించబడే పునర్వినియోగ విధులను నిర్వచిస్తుంది. సాధనం సరిగ్గా పని చేస్తుందని నిర్ధారించడానికి, ఇన్పుట్ స్కీమా Zod లైబ్రరీతో ధృవీకరించబడుతుంది, ఇన్పుట్ చెల్లుబాటు అయ్యే సంఖ్య అని హామీ ఇస్తుంది. ఇది సరైన లోపం నిర్వహణను నిర్ధారిస్తుంది మరియు చెల్లని ఇన్పుట్ల కారణంగా సాధనం విఫలం కాకుండా నిరోధిస్తుంది.
కస్టమ్ సాధనం ఉపయోగించి ఏజెంట్లో చేర్చబడుతుంది ఫంక్షన్. ఈ కమాండ్ అవసరమైనప్పుడు సాధనాన్ని కాల్ చేయడానికి ఏజెంట్ను అనుమతిస్తుంది మరియు ఏజెంట్ ఒల్లామా మోడల్ ద్వారా శక్తిని పొందుతుంది, ఇది ప్రతిస్పందనల సృజనాత్మకతను నియంత్రించడానికి ఉష్ణోగ్రత వంటి నిర్దిష్ట పారామితులతో కాన్ఫిగర్ చేయబడింది. ఏజెంట్ మరియు సాధనం మధ్య సున్నితమైన పరస్పర చర్యను సులభతరం చేయడానికి, చాట్ ప్రాంప్ట్ టెంప్లేట్ ఉపయోగించబడుతుంది. ఈ టెంప్లేట్ సిస్టమ్ సందేశాలు, మానవ ఇన్పుట్ మరియు ప్లేస్హోల్డర్ల వంటి వివిధ రకాల సందేశాలను నిర్వచించడం ద్వారా సంభాషణను నిర్వహిస్తుంది. ప్లేస్హోల్డర్లు, వంటివి , చాట్ చరిత్ర వంటి అంశాలతో సంభాషణ డైనమిక్గా ఉండటానికి అనుమతించండి.
లాంగ్చెయిన్ ఏజెంట్ అవుట్పుట్ పార్సింగ్ చుట్టూ ఉన్న ఎర్రర్ హ్యాండ్లింగ్ ఈ ఉదాహరణలో ప్రస్తావించబడిన ముఖ్య సమస్యలలో ఒకటి. "ParseResult on ToolCallingAgentOutputParser ChatGeneration అవుట్పుట్లో మాత్రమే పని చేస్తుంది" అనే దోష సందేశం పార్సర్ ఆశించిన అవుట్పుట్ రకం మరియు ఉత్పత్తి చేయబడిన వాస్తవ అవుట్పుట్ మధ్య అసమతుల్యత నుండి వచ్చింది. ఈ లోపాన్ని నిర్వహించడానికి, అనుకూల సాధనం బలమైన లాజిక్తో చుట్టబడి ఉంటుంది, అన్ని ఇన్పుట్లు మరియు అవుట్పుట్లు ఆశించిన ఫార్మాట్లకు అనుగుణంగా ఉన్నాయని నిర్ధారిస్తుంది. ఇది మరింతగా నిర్వహించబడుతుంది తరగతి, ఇది ఏజెంట్ మరియు సాధనాల అమలును సమన్వయం చేస్తుంది, ప్రశ్న మరియు సాధనం అవుట్పుట్ సరిగ్గా సమకాలీకరించబడిందని నిర్ధారించుకోండి.
చివరగా, స్క్రిప్ట్లు అసమకాలిక అమలును ఉపయోగించి అమలు చేస్తాయి , ఇతర ప్రక్రియలను నిరోధించకుండా కార్యకలాపాలను నిర్వహించడానికి సిస్టమ్ను అనుమతిస్తుంది. ప్రతిస్పందన ఖచ్చితమైనది మరియు సమయానుకూలంగా ఉందని నిర్ధారిస్తూ, కొనసాగడానికి ముందు సాధనం దాని ఫలితాన్ని అందించడానికి ఏజెంట్ వేచి ఉంటాడు. అదనంగా, సాధనం యొక్క కార్యాచరణను ధృవీకరించడానికి యూనిట్ పరీక్షలు చేర్చబడ్డాయి, ఇది స్థిరంగా సరైన అవుట్పుట్ను ఉత్పత్తి చేస్తుందని నిర్ధారిస్తుంది. ఈ పరీక్షలు సాధనం యొక్క గణిత శాస్త్ర ఆపరేషన్ను నిర్ధారించడమే కాకుండా, పరిష్కారం యొక్క మొత్తం విశ్వసనీయతను మెరుగుపరుస్తూ, చెల్లని ఇన్పుట్ను ఎంత బాగా నిర్వహిస్తుందో కూడా తనిఖీ చేస్తుంది. ఈ మాడ్యులర్ మరియు ఎర్రర్-రెసిస్టెంట్ డిజైన్ Langchain.jsలోని వివిధ అప్లికేషన్ల కోసం స్క్రిప్ట్లను పునర్వినియోగం మరియు ప్రభావవంతంగా చేస్తుంది.
మాడ్యులర్ అప్రోచ్తో Langchain.js లోపాన్ని పరిష్కరించడం
పరిష్కారం 1: మాడ్యులర్ విధానంతో జావాస్క్రిప్ట్ మరియు Langchain.js మరియు Ollama LLMని ఉపయోగించి లోపం నిర్వహణ
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 Ollamaconst llm = new Ollama({model: "llama3",temperature: 0.7,});// Custom tool to add 2 to the input numberconst 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 placeholdersconst prompt = ChatPromptTemplate.fromMessages([["system", "You are a helpful assistant called iHelp"],["placeholder", "{chat_history}"],["human", "{input}"],["placeholder", "{agent_scratchpad}"],]);// Agent configurationconst agent = createToolCallingAgent({ llm, tools, prompt });// Execute agent queryconst agentExecutor = new AgentExecutor({ agent, tools });const query = "What is the value of magic_function(3)?";await agentExecutor.invoke({ input: query });
Langchain.js ఏజెంట్ కోసం మెరుగుపరచబడిన ఎర్రర్ హ్యాండ్లింగ్
పరిష్కారం 2: Langchain.jsలో కస్టమ్ టూల్ అవుట్పుట్ను ధృవీకరించడానికి యూనిట్ పరీక్షలతో నిర్వహించడంలో లోపం
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 Ollamaconst llm = new Ollama({ model: "llama3", temperature: 0.7 });// Custom tool with added error handlingconst 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 executionconst agent = createToolCallingAgent({ llm, tools });const agentExecutor = new AgentExecutor({ agent, tools });const query = "magic_function('abc')"; // Test with invalid inputawait agentExecutor.invoke({ input: query });// Unit test exampleimport { 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తో పని చేస్తున్నప్పుడు, సమగ్రపరచడం ఒల్లామా వంటి సాధనాలు మరియు భాషా నమూనాలు డైనమిక్ అప్లికేషన్లను రూపొందించడంలో కీలకమైన అంశం. నిర్దిష్ట విధులను నిర్వర్తించే కస్టమ్ టూల్ను మరింత సంభాషణ లేదా ఉత్పాదక పనులను నిర్వహించే భాషా నమూనాకు కనెక్ట్ చేయడానికి ఏజెంట్ మిమ్మల్ని అనుమతిస్తుంది. ఏజెంట్లను ఉపయోగించడం ద్వారా, డెవలపర్లు వర్క్ఫ్లోలను ఆటోమేట్ చేయగలరు, ఇక్కడ మోడల్ ప్రతిస్పందనలను రూపొందించడమే కాకుండా లెక్కలు లేదా డేటా ప్రాసెసింగ్ చేయడానికి సాధనాలను కూడా ప్రేరేపిస్తుంది.
ఈ ఏకీకరణలో కీలకమైన అంశం ఫంక్షన్. ఈ ఫంక్షన్ అవసరమైనప్పుడు నిర్దిష్ట సాధనాలను ట్రిగ్గర్ చేయడానికి ఏజెంట్ను అనుమతిస్తుంది, టాస్క్లు ఖచ్చితంగా మరియు సమర్ధవంతంగా పూర్తయ్యాయని నిర్ధారిస్తుంది. ప్రాథమిక దృష్టి తరచుగా సాధనాన్ని సృష్టించడంపైనే ఉంటుంది, ఏజెంట్ యొక్క వర్క్ఫ్లోను ఎలా నిర్వహించాలో మరియు పార్సింగ్ లోపాలను ఎలా నివారించాలో అర్థం చేసుకోవడం కూడా అంతే ముఖ్యం. ఏజెంట్ అవుట్పుట్ పార్సింగ్ సిస్టమ్కు అనుకూలంగా లేనప్పుడు, ఏజెంట్ అవుట్పుట్ మరియు ఆశించిన ఆకృతికి మధ్య సరైన అమరిక అవసరాన్ని హైలైట్ చేస్తూ, "ParseResult on ToolCallingAgentOutputParser ChatGeneration అవుట్పుట్లో మాత్రమే పని చేస్తుంది" వంటి లోపాలు సాధారణంగా సంభవిస్తాయి.
వంటి ప్రాంప్ట్ టెంప్లేట్ల ఉపయోగం , డైనమిక్ సందేశాలు మరియు కాంటెక్స్ట్ ప్లేస్హోల్డర్లను అనుమతించడం ద్వారా పరస్పర చర్యను మరింత మెరుగుపరుస్తుంది. ఇది చాట్ చరిత్ర లేదా ఏజెంట్ స్క్రాచ్ప్యాడ్ ఆధారంగా దాని ప్రతిస్పందనలను సర్దుబాటు చేయడానికి ఏజెంట్ను అనుమతిస్తుంది. ప్రాంప్ట్ టెంప్లేట్లను ఆప్టిమైజ్ చేయడం మరియు ఏజెంట్ యొక్క అవుట్పుట్లు సరిగ్గా అన్వయించబడ్డాయని నిర్ధారించుకోవడం వలన మీ Langchain.js అప్లికేషన్లను మరింత విశ్వసనీయంగా మరియు సమర్ధవంతంగా చేయడం ద్వారా అనేక సాధారణ లోపాలను నివారించవచ్చు.
- Langchain.jsలో ఏజెంట్ అంటే ఏమిటి?
- ఏజెంట్ అనేది వినియోగదారు ప్రశ్న ఆధారంగా నిర్దిష్ట పనులను నిర్వహించడానికి సాధనాలు మరియు భాషా నమూనాలతో పరస్పర చర్య చేసే ఒక భాగం. ఇది ఉపయోగిస్తుంది సాధనాలను ట్రిగ్గర్ చేయడానికి ఫంక్షన్.
- మీరు "ParseResult on ToolCallingAgentOutputParser" లోపాన్ని ఎలా పరిష్కరిస్తారు?
- ఏజెంట్ అవుట్పుట్ పార్సర్కి అనుకూలంగా లేనప్పుడు ఈ లోపం సంభవిస్తుంది. పార్సర్ ఆశించిన దానితో అవుట్పుట్ సరిపోలినట్లు నిర్ధారించుకోండి మరియు a ఉపయోగించండి అవుట్పుట్ ఫార్మాట్.
- యొక్క ప్రయోజనం ఏమిటి ?
- ది ఏజెంట్ మరియు దాని సాధనాల అమలును నిర్వహిస్తుంది, Langchain.js అప్లికేషన్లలో సంక్లిష్టమైన వర్క్ఫ్లోలను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
- ఎలా చేస్తుంది పని?
- చాట్ మెసేజ్లను స్ట్రక్చర్డ్ ఫార్మాట్లో నిర్వహిస్తుంది, చాట్ హిస్టరీ మరియు ఏజెంట్ స్క్రాచ్ప్యాడ్ వంటి డైనమిక్ కంటెంట్ను సంభాషణ ఫ్లోలో చొప్పించడానికి అనుమతిస్తుంది.
- ఎందుకు ఉంది సాధనంలో ఉపయోగించారా?
- ఇన్పుట్ ధ్రువీకరణ కోసం ఉపయోగించబడుతుంది, అనుకూల సాధనానికి ఇన్పుట్ సరైన రకం (ఉదా., ఒక సంఖ్య) అని నిర్ధారిస్తుంది, ఇది లోపాల అవకాశాలను తగ్గిస్తుంది.
"ParseResult on ToolCallingAgentOutputParser ChatGeneration అవుట్పుట్లో మాత్రమే పని చేస్తుంది" లోపాన్ని పరిష్కరించడానికి మీ ఏజెంట్ అవుట్పుట్ మరియు దాని పార్సింగ్ అంచనాల మధ్య జాగ్రత్తగా సమలేఖనం అవసరం. సరైన విధానంతో, ఈ లోపాన్ని నివారించవచ్చు.
ధృవీకరణ కోసం Zod వంటి సముచిత సాధనాలను ఉపయోగించడం ద్వారా మరియు Ollamaతో రూపొందించబడిన ఏజెంట్లు ఇన్పుట్లు మరియు అవుట్పుట్లను సరిగ్గా నిర్వహించేలా చూసుకోవడం ద్వారా, మీరు పార్సింగ్ సమస్యలను ఎదుర్కోకుండా Langchain.jsలో బలమైన పరిష్కారాలను సృష్టించవచ్చు.
- అధికారిక లాంగ్చెయిన్ డాక్యుమెంటేషన్పై వివరిస్తుంది, ఇది సాధనాల సృష్టి మరియు ఏజెంట్ కాన్ఫిగరేషన్లపై అంతర్దృష్టులను అందిస్తుంది. లాంగ్చెయిన్ డాక్యుమెంటేషన్ లోపల.
- Langchain.jsలో ఇన్పుట్ ధ్రువీకరణ మరియు దాని అప్లికేషన్ కోసం Zod ఉపయోగాన్ని మరింత వివరిస్తుంది. Zod డాక్యుమెంటేషన్ లోపల.
- ఒల్లామా భాషా నమూనా మరియు అనుకూల ఏజెంట్లలో దాని అమలును వివరిస్తుంది. ఒల్లామా LLM లోపల.