Tools always modified the req and res from script how to stop

[LakshyaTambi]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

This is my nest file------------------------------------->/*eslint-disable*/
import { Controller, Post, Body, Get } from '@nestjs/common';
import { LangChainService } from './langchain.service';

function extractEndpointDetails(text: string): any {
  const endpointRegex = /Endpoint:\s*(.*)/;
  const nameRegex = /Name:\s*(.*)/;
  const methodRegex = /Method:\s*(.*)/;
  const typeRegex = /Type:\s*(.*)/;
  const hostRegex = /Host:\s*(.*)/;

  const endpointMatch = text.match(endpointRegex);
  const nameMatch = text.match(nameRegex);
  const methodMatch = text.match(methodRegex);
  const typeMatch = text.match(typeRegex);
  const hostMatch = text.match(hostRegex);

  const endpointDetails: any = {
    endpoint: endpointMatch ? endpointMatch[1].trim() : '',
    name: nameMatch ? nameMatch[1].trim() : '',
    method: methodMatch ? methodMatch[1].trim() : '',
    type: typeMatch ? typeMatch[1].trim() : '',
    host: hostMatch ? hostMatch[1].trim() : ''
  };

  return endpointDetails;
}
@Controller('langchain')
export class LangChainController {
  constructor(private readonly langChainService: LangChainService) {}

  @Get()
  getHello(): string {
    return "Hello World"; // Responds with "Hello World" for GET requests to '/langchain'
  }

  @Post('invoke')
  async invokeAgent(@Body('query') input: any) {
    // let data = JSON.parse(input)
    // // console.log(data.text)
    console.log(input.text)
    const agentExecutor = this.langChainService.getAgentExecutor(); // Retrieves agent executor from LangChainService
  //  console.log(agentExecutor);
  input = JSON.stringify(input)
  // console.log("This is input", input)

    // Logs the agent executor object to the console
    const result = await agentExecutor.invoke({ input }); // Invokes the agent with the provided input
    console.log("This is output", result.output)
    // let ans = extractEndpointDetails(result.output)
    // console.log("This is ans", ans)
    return result.output; // Returns the output from the agent invocation
  }
}
this is my service file ----------------------------------------------->/*eslint-disable*/
import { Injectable, OnModuleInit } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { ChatOpenAI } from '@langchain/openai';
import { createOpenAIFunctionsAgent, AgentExecutor } from 'langchain/agents';
import { pull } from 'langchain/hub';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { ToolMetadata } from '@langchain/decorators/tool.decorator';
import { DynamicStructuredTool } from '@langchain/core/tools';
import { BufferMemory } from "langchain/memory";
import { memory } from '@tensorflow/tfjs';
import { ConversationSummaryMemory } from "langchain/memory";
@Injectable()
export class LangChainService implements OnModuleInit {
  private llm: ChatOpenAI;
  private agent: any; // Use appropriate type
  private agentExecutor: AgentExecutor;
  private tools: any[] = [];
 
  constructor(private configService: ConfigService) {}

  async onModuleInit() {
    const apiKey = this.configService.get<string>('SIMPLE_LLM_API_KEY');
    const model = this.configService.get<string>('SIMPLE_LLM_MODEL');
    this.llm = new ChatOpenAI({
      model,
      temperature: 0,
      apiKey,
    });
    
    const prompt = await pull<ChatPromptTemplate>(
      'hwchase17/openai-functions-agent',
    );
    // const prompy = "This tool dont"

    this.agent = await createOpenAIFunctionsAgent({
      llm: this.llm as any,
      tools: this.tools,
      prompt,
    });

    this.agentExecutor = new AgentExecutor({
      agent: this.agent,
      tools: this.tools,
    });
  }

  // eslint-disable-next-line @typescript-eslint/ban-types
  registerTool(method: Function, metadata: ToolMetadata) {
    // eslint-disable-next-line @typescript-eslint/no-unused-vars
    const { name, description, schema } = metadata;
    const tool = new DynamicStructuredTool({
      name,
      description,
      schema,
      func: async (input: any): Promise<any> => {
        return await method(input); // Adjust the method invocation as needed
      },
    });
    this.tools.push(tool);
  }

  getAgentExecutor() {
    return this.agentExecutor;
  }
}

@Injectable()
export class ChainService {
  constructor(private readonly langChainService: LangChainService) {}

  async processPrompt(prompt: string) {
    const memory = new ConversationSummaryMemory({
      memoryKey: "chat_history",
      llm: new ChatOpenAI({ model: "gpt-3.5-turbo", temperature: 0 }),
    });
    const agentExecutor = this.langChainService.getAgentExecutor();
    const result = await agentExecutor.invoke({
      input: prompt,
      memory
    });
    console.log(result.output);
    await memory.loadMemoryVariables({})
    return result.output;
  }
}
this is my tools ---------------------------------> /*eslint-disable*/
// File: src/langchain/tools/example.tool.ts
import { Injectable } from '@nestjs/common';
import { Tool } from '@langchain/decorators/tool.decorator';
import { WikipediaQueryRun } from '@langchain/community/tools/wikipedia_query_run';
import { z } from 'zod';
// // import main from '../functions/swagger.js'
// import { Swagger } from '@langchain/functions/swagger.ts';
// import { Swagger } from '@langchain/functions/swagger';
import { Workflow } from '@langchain/functions/workflow';
// import { Swagger } from '@langchain/functions/expression';
import { Swagger } from '@langchain/functions/swagger';
import { Expression } from '@langchain/functions/expression';
import { workflowCreation } from '@langchain/functions/workflowCreation';
@Injectable()
export class ExampleTool {
  @Tool({
    name: 'exampleTool',
    description: 'This is an example tool',
    schema: z.object({
      input: z.string(),
    }),
  })
  exampleMethod({ input }): string {
    // Tool logic goes here
    return `Processed input: ${input}`;
  }

  @Tool({
    name: 'anotherTool',
    description: 'This is another example tool',
    schema: z.object({
      input: z.number(),
    }),
  })
  anotherMethod({ input }): string {
    return (input * 2).toString();
  }

  @Tool({
    name: 'queryWikipedia',
    description: 'Queries Wikipedia for information',
    schema: z.object({
      query: z.string(),
    }),
  })
  async queryWikipedia({ query }: { query: string }): Promise<string> {
    console.log("???????????????????????????????????? Wikipedia for information")
    const tool = new WikipediaQueryRun({
      topKResults: 3,
      maxDocContentLength: 4000,
    });

    const result = await tool.invoke(query);
    return result;
  }
  @Tool({
    name: 'Apirecommendationsworkflow',
    description: 'This is the tool that provide the endpoint based on the user query',
    schema: z.object({
      query: z.string(),
    }),
  })

  async swagger({query}:{query:string}):Promise<string> {
    console.log("???????????????????????????API RECOMMENDATION TOOL")
     let ans = await Swagger(query)
     console.log("This is the answer from the endpoint: ",ans)
      return ans
  }
  // @Tool({
  //   name: 'WorkflowCreaterTool',
  //   description: 'This tool will return the mermaid code and please please please give correct mermaid code you always forget the arrow before the end node give just code and nothing else',
  //   schema: z.object({
  //     query: z.string(),
  //   }),
  // })

  // async workflow({query}:{query:string}):Promise<string> {
  //   console.log("???????????????????????????WORKFLOW TOOL")
  //    let ans = await Workflow(query)
  //    console.log("This is the answer from the endpoint: ",ans)
  //     return ans
  // } 
  @Tool({
    name: 'ExpressionTool',
    description: 'This is expression tool which provide all the expression value that what can be made',
    schema: z.object({
      query: z.string(),
    }),
  })
  async expression({query}:{query:string}):Promise<string> {
    console.log("???????????????????????????Expression Tool",typeof(query))
     let ans = await Expression(query)
     console.log("This is the answer from the endpoint: ",ans)
    //  console.log("This is the answer from the endpoint: ",ans)
      return ans
  } 
  @Tool({
    name: 'WorkflowCreationTool',
    description: 'This is a tool that give answer in json format to that gives you the relevant endpoint url , method , type , host url , endpoint name of relevant endpoints to create workflow  ',
    schema: z.object({
      query: z.string(),
    }),
  })
  async workflowcreation({query}:{query:string}):Promise<string> {
    console.log("???????????????????????????Worflow Creation Tool",typeof(query))
     let ans = await workflowCreation(query)
     console.log("This is the answer from the endpoint: ",ans)
    //  console.log("This is the answer from the endpoint: ",ans)
      return ans
  } 
}

Description

when i send the query based on the tool description is finds well that what function to run but when the request came tool modifed the req as well as when the response came tool again modified the response I dont want that these modified the req and res how to do this

System Info

ok

[dosubot[bot]]

To prevent tools from modifying the request and response objects in your LangChain setup, you can leverage the callbacks property to control and monitor the request and response flow. Here’s how you can do it:

1. Define Callbacks: Create callback functions to handle the request and response without modifying them.

2. Configure Callbacks in Tools: Use these callbacks in your tools to ensure the request and response are not altered.

Here’s an example of how you can implement this:

Step 1: Define Callbacks

Create a callback manager to handle the request and response:

import { CallbackManager } from 'langchain/core/callbacks';

const callbackManager = new CallbackManager({
  handleToolStart: (tool, input) => {
    console.log(`Tool ${tool.name} started with input:`, input);
  },
  handleToolEnd: (tool, output) => {
    console.log(`Tool ${tool.name} ended with output:`, output);
  },
  handleToolError: (tool, error) => {
    console.error(`Tool ${tool.name} encountered an error:`, error);
  },
});

Step 2: Configure Callbacks in Tools

Pass the callback manager to your tools when you register them:

import { DynamicStructuredTool } from '@langchain/core/tools';
import { z } from 'zod';

const exampleTool = new DynamicStructuredTool({
  name: 'exampleTool',
  description: 'This is an example tool',
  schema: z.object({
    input: z.string(),
  }),
  func: async ({ input }) => {
    return `Processed input: ${input}`;
  },
  callbacks: callbackManager,
});

Step 3: Use Callbacks in Service

Ensure your service uses these tools with the defined callbacks:

import { Injectable, OnModuleInit } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { ChatOpenAI } from '@langchain/openai';
import { createOpenAIFunctionsAgent, AgentExecutor } from 'langchain/agents';
import { DynamicStructuredTool } from '@langchain/core/tools';

@Injectable()
export class LangChainService implements OnModuleInit {
  private llm: ChatOpenAI;
  private agent: any;
  private agentExecutor: AgentExecutor;
  private tools: any[] = [];

  constructor(private configService: ConfigService) {}

  async onModuleInit() {
    const apiKey = this.configService.get<string>('SIMPLE_LLM_API_KEY');
    const model = this.configService.get<string>('SIMPLE_LLM_MODEL');
    this.llm = new ChatOpenAI({
      model,
      temperature: 0,
      apiKey,
    });

    const prompt = await pull<ChatPromptTemplate>(
      'hwchase17/openai-functions-agent',
    );

    this.agent = await createOpenAIFunctionsAgent({
      llm: this.llm as any,
      tools: this.tools,
      prompt,
    });

    this.agentExecutor = new AgentExecutor({
      agent: this.agent,
      tools: this.tools,
    });
  }

  registerTool(method: Function, metadata: ToolMetadata) {
    const { name, description, schema } = metadata;
    const tool = new DynamicStructuredTool({
      name,
      description,
      schema,
      func: async (input: any): Promise<any> => {
        return await method(input);
      },
      callbacks: callbackManager,
    });
    this.tools.push(tool);
  }

  getAgentExecutor() {
    return this.agentExecutor;
  }
}

Step 4: Invoke Agent with Callbacks

When invoking the agent, ensure the callbacks are passed:

import { Controller, Post, Body, Get } from '@nestjs/common';
import { LangChainService } from './langchain.service';

@Controller('langchain')
export class LangChainController {
  constructor(private readonly langChainService: LangChainService) {}

  @Get()
  getHello(): string {
    return "Hello World";
  }

  @Post('invoke')
  async invokeAgent(@Body('query') input: any) {
    const agentExecutor = this.langChainService.getAgentExecutor();
    const result = await agentExecutor.invoke(
      { input },
      { callbacks: callbackManager }
    );
    return result.output;
  }
}

By using the callbacks property, you can ensure that the request and response objects are handled properly without being modified by the tools ^[1][2].

To continue talking to Dosu, mention @dosu.

[LakshyaTambi]

/eslint-disable/
// File: src/langchain/tools/example.tool.ts
import { Injectable } from '@nestjs/common';
import { Tool } from '@langchain/decorators/tool.decorator';
import { WikipediaQueryRun } from '@langchain/community/tools/wikipedia_query_run';
import { z } from 'zod';
import { CallbackManager } from 'langchain/core/callbacks'
// // import main from '../functions/swagger.js'
// import { Swagger } from '@langchain/functions/swagger.ts';
// import { Swagger } from '@langchain/functions/swagger';
import { Workflow } from '@langchain/functions/workflow';
// import { Swagger } from '@langchain/functions/expression';
import { Swagger } from '@langchain/functions/swagger';
import { Expression } from '@langchain/functions/expression';
import { workflowCreation } from '@langchain/functions/workflowCreation';

const callbackManager = new CallbackManager({
handleToolStart: (tool, input) => {
console.log(Tool ${tool.name} started with input:, input);
},
handleToolEnd: (tool, output) => {
console.log(Tool ${tool.name} ended with output:, output);
},
handleToolError: (tool, error) => {
console.error(Tool ${tool.name} encountered an error:, error);
},
});
@Injectable()
export class ExampleTool {
@tool({
name: 'exampleTool',
description: 'This is an example tool',
schema: z.object({
input: z.string(),
}),
})
exampleMethod({ input }): string {
// Tool logic goes here
return Processed input: ${input};
}

@tool({
name: 'anotherTool',
description: 'This is another example tool',
schema: z.object({
input: z.number(),
}),
})
anotherMethod({ input }): string {
return (input * 2).toString();
}

@tool({
name: 'queryWikipedia',
description: 'Queries Wikipedia for information',
schema: z.object({
query: z.string(),
}),
})
async queryWikipedia({ query }: { query: string }): Promise {
console.log("???????????????????????????????????? Wikipedia for information")
const tool = new WikipediaQueryRun({
topKResults: 3,
maxDocContentLength: 4000,
});

const result = await tool.invoke(query);
return result;

}
@tool({
name: 'Apirecommendationsworkflow',
description: 'This is the tool that provide the endpoint based on the user query',
schema: z.object({
query: z.string(),
}),
})

async swagger({query}:{query:string}):Promise {
console.log("???????????????????????????API RECOMMENDATION TOOL")
let ans = await Swagger(query)
console.log("This is the answer from the endpoint: ",ans)
return ans
}
// @tool({
// name: 'WorkflowCreaterTool',
// description: 'This tool will return the mermaid code and please please please give correct mermaid code you always forget the arrow before the end node give just code and nothing else',
// schema: z.object({
// query: z.string(),
// }),
// })

// async workflow({query}:{query:string}):Promise {
// console.log("???????????????????????????WORKFLOW TOOL")
// let ans = await Workflow(query)
// console.log("This is the answer from the endpoint: ",ans)
// return ans
// }
@tool({
name: 'ExpressionTool',
description: 'This is expression tool which provide all the expression value that what can be made',
schema: z.object({
query: z.string(),
}),
})
async expression({query}:{query:string}):Promise {
console.log("???????????????????????????Expression Tool",typeof(query))
let ans = await Expression(query)
console.log("This is the answer from the endpoint: ",ans)
// console.log("This is the answer from the endpoint: ",ans)
return ans
}
@tool({
name: 'WorkflowCreationTool',
description: 'This is a tool that give answer in json format to that gives you the relevant endpoint url , method , type , host url , endpoint name of relevant endpoints to create workflow ',
schema: z.object({
query: z.string(),
}),
})
async workflowcreation({query}:{query:string}):Promise {
console.log("???????????????????????????Worflow Creation Tool",typeof(query))
let ans = await workflowCreation(query)
console.log("This is the answer from the endpoint: ",ans)
// console.log("This is the answer from the endpoint: ",ans)
return ans
}
}
How to add callback manager in these tool please add so I can take reference

[dosubot[bot]]

To add a CallbackManager to your tools in LangChain, you can follow these steps:

1. Create a CallbackManager instance.
2. Pass the CallbackManager to each tool.

Here’s how you can do it:

Step 1: Create a CallbackManager Instance

First, create a CallbackManager instance with the necessary handlers:

import { CallbackManager } from 'langchain/core/callbacks';

const callbackManager = new CallbackManager({
  handleToolStart: (tool, input) => {
    console.log(`Tool ${tool.name} started with input:`, input);
  },
  handleToolEnd: (tool, output) => {
    console.log(`Tool ${tool.name} ended with output:`, output);
  },
  handleToolError: (tool, error) => {
    console.error(`Tool ${tool.name} encountered an error:`, error);
  },
});

Step 2: Pass the CallbackManager to Each Tool

Modify your tools to accept and use the CallbackManager:

import { Injectable } from '@nestjs/common';
import { Tool } from '@langchain/decorators/tool.decorator';
import { WikipediaQueryRun } from '@langchain/community/tools/wikipedia_query_run';
import { z } from 'zod';
import { CallbackManager } from 'langchain/core/callbacks';
import { Swagger } from '@langchain/functions/swagger';
import { Expression } from '@langchain/functions/expression';
import { workflowCreation } from '@langchain/functions/workflowCreation';

const callbackManager = new CallbackManager({
  handleToolStart: (tool, input) => {
    console.log(`Tool ${tool.name} started with input:`, input);
  },
  handleToolEnd: (tool, output) => {
    console.log(`Tool ${tool.name} ended with output:`, output);
  },
  handleToolError: (tool, error) => {
    console.error(`Tool ${tool.name} encountered an error:`, error);
  },
});

@Injectable()
export class ExampleTool {
  @Tool({
    name: 'exampleTool',
    description: 'This is an example tool',
    schema: z.object({
      input: z.string(),
    }),
  })
  exampleMethod({ input }): string {
    return `Processed input: ${input}`;
  }

  @Tool({
    name: 'anotherTool',
    description: 'This is another example tool',
    schema: z.object({
      input: z.number(),
    }),
  })
  anotherMethod({ input }): string {
    return (input * 2).toString();
  }

  @Tool({
    name: 'queryWikipedia',
    description: 'Queries Wikipedia for information',
    schema: z.object({
      query: z.string(),
    }),
  })
  async queryWikipedia({ query }: { query: string }): Promise<string> {
    console.log("???????????????????????????????????? Wikipedia for information");
    const tool = new WikipediaQueryRun({
      topKResults: 3,
      maxDocContentLength: 4000,
    });

    const result = await tool.invoke(query, { callbacks: callbackManager });
    return result;
  }

  @Tool({
    name: 'Apirecommendationsworkflow',
    description: 'This is the tool that provide the endpoint based on the user query',
    schema: z.object({
      query: z.string(),
    }),
  })
  async swagger({ query }: { query: string }): Promise<string> {
    console.log("???????????????????????????API RECOMMENDATION TOOL");
    let ans = await Swagger(query, { callbacks: callbackManager });
    console.log("This is the answer from the endpoint: ", ans);
    return ans;
  }

  @Tool({
    name: 'ExpressionTool',
    description: 'This is expression tool which provide all the expression value that what can be made',
    schema: z.object({
      query: z.string(),
    }),
  })
  async expression({ query }: { query: string }): Promise<string> {
    console.log("???????????????????????????Expression Tool", typeof(query));
    let ans = await Expression(query, { callbacks: callbackManager });
    console.log("This is the answer from the endpoint: ", ans);
    return ans;
  }

  @Tool({
    name: 'WorkflowCreationTool',
    description: 'This is a tool that give answer in json format to that gives you the relevant endpoint url , method , type , host url , endpoint name of relevant endpoints to create workflow',
    schema: z.object({
      query: z.string(),
    }),
  })
  async workflowcreation({ query }: { query: string }): Promise<string> {
    console.log("???????????????????????????Worflow Creation Tool", typeof(query));
    let ans = await workflowCreation(query, { callbacks: callbackManager });
    console.log("This is the answer from the endpoint: ", ans);
    return ans;
  }
}

In this example, the CallbackManager is passed to each tool's invocation to ensure that the request and response objects are handled properly without being modified by the tools ^[1].

To continue talking to Dosu, mention @dosu.

[LakshyaTambi]

but my function like swagger is not accepting callbackmanager it only accept query