Replies: 2 comments 26 replies
-
|
Hey @depshad! I'm here to help you with any bugs, questions, or contributions you have. Let's solve this together! To skip the usage of def _call(
self,
inputs: Dict[str, Any],
run_manager: Optional[CallbackManagerForChainRun] = None,
) -> Dict[str, str]:
_run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
intermediate_steps = {}
instructions = inputs[self.instructions_key]
instructions = instructions[: self.max_text_length]
# Directly deserialize the JSON input without using predict_and_parse
api_arguments = json.dumps(inputs)
intermediate_steps["request_args"] = api_arguments
_run_manager.on_text(
api_arguments, color="green", end="\n", verbose=self.verbose
)
if api_arguments.startswith("ERROR"):
return self._get_output(api_arguments, intermediate_steps)
elif api_arguments.startswith("MESSAGE:"):
return self._get_output(
api_arguments[len("MESSAGE:") :], intermediate_steps
)
try:
request_args = self.deserialize_json_input(api_arguments)
method = getattr(self.requests, self.api_operation.method.value)
api_response: Response = method(**request_args)
if api_response.status_code != 200:
method_str = str(self.api_operation.method.value)
response_text = (
f"{api_response.status_code}: {api_response.reason}"
+ f"\nFor {method_str.upper()} {request_args['url']}\n"
+ f"Called with args: {request_args['params']}"
)
else:
response_text = api_response.text
except Exception as e:
response_text = f"Error with message {str(e)}"
response_text = response_text[: self.max_text_length]
intermediate_steps["response_text"] = response_text
_run_manager.on_text(
response_text, color="blue", end="\n", verbose=self.verbose
)
if self.api_response_chain is not None:
_answer = self.api_response_chain.predict_and_parse(
response=response_text,
instructions=instructions,
callbacks=_run_manager.get_child(),
)
answer = cast(str, _answer)
_run_manager.on_text(answer, color="yellow", end="\n", verbose=self.verbose)
return self._get_output(answer, intermediate_steps)
else:
return self._get_output(response_text, intermediate_steps)This modification ensures that the JSON payload is directly deserialized and used without being altered by the |
Beta Was this translation helpful? Give feedback.
-
|
@dosu "The predict_and_parse method is deprecated, and it is recommended to pass an output parser directly to LLMChain instead" |
Beta Was this translation helpful? Give feedback.
-
|
Passing an output parser directly to Here is an example of how to pass an output parser directly to from langchain.chains import LLMChain
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_community.llms import OpenAI
prompt_template = "Tell me a {adjective} joke"
prompt = PromptTemplate(
input_variables=["adjective"], template=prompt_template
)
llm = OpenAI()
output_parser = StrOutputParser()
chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser)
result = chain.predict(adjective="funny")
print(result)In this example, the Alternatively, you can chain the model with the output parser using the chain = llm | output_parser
result = chain.invoke(["Tell me a funny joke"])
print(result)In this case, the chain has two steps: first, the language model is called, then the result of that is passed to the output parser. Here is an additional example from the LangChain unit tests that demonstrates the use of a custom output parser: from langchain.chains.llm import LLMChain
from langchain_core.output_parsers import BaseOutputParser
from langchain_core.prompts import PromptTemplate
from tests.unit_tests.llms.fake_llm import FakeLLM
class FakeOutputParser(BaseOutputParser):
"""Fake output parser class for testing."""
def parse(self, text: str):
"""Parse by splitting."""
return text.split()
prompt = PromptTemplate(
input_variables=["foo"], template="{foo}", output_parser=FakeOutputParser()
)
llm = FakeLLM(queries={"foo": "foo bar"})
chain = LLMChain(prompt=prompt, llm=llm)
output = chain.predict_and_parse(foo="foo")
assert output == ["foo", "bar"]In this example, the |
Beta Was this translation helpful? Give feedback.
-
|
@dosu while using the solution for passing input schema which involves _get_structured_tool and get_param_fields, we do not use the api docs but rather use the openapi sepcification as seen in the original code. How can we modify this code to get the relevant param fields from openapi spec instead of the docs. |
Beta Was this translation helpful? Give feedback.
-
|
To modify the code to get the relevant parameter fields from the OpenAPI specification instead of the API docs while using the solution that involves Here is the relevant part of the code that shows how from pydantic import create_model
from typing import Any, Dict
def _get_structured_tool(
endpoint: str, docs: dict, tools_args: Dict[str, Any]
) -> StructuredTool:
fields = get_param_fields(docs)
_DynamicToolInputSchema = create_model("DynamicToolInputSchema", **fields)
def dynamic_func(**data: dict[str, Any]) -> str:
return chain.run(**data)
dynamic_func.__name__ = tools_args["name"]
dynamic_func.__doc__ = tools_args["description"]
return StructuredTool(
func=dynamic_func,
args_schema=_DynamicToolInputSchema,
**tools_args,
)In this code, Additionally, the def test_get_tools_success() -> None:
# Setup
toolkit_instance = ActionServerToolkit(
url="http://example.com", api_key="dummy_key"
)
fixture_path = Path(__file__).with_name("_openapi2.fixture.json")
with patch(
"langchain_robocorp.toolkits.requests.get"
) as mocked_get, fixture_path.open("r") as f:
data = json.load(f)
mocked_response = MagicMock()
mocked_response.json.return_value = data
mocked_response.status_code = 200
mocked_response.headers = {"Content-Type": "application/json"}
mocked_get.return_value = mocked_response
# Execute
tools = toolkit_instance.get_tools()
# Verify
assert len(tools) == 5
tool = tools[2]
assert tool.name == "add_sheet_rows"
assert tool.description == (
"Action to add multiple rows to the Google sheet. "
"Get the sheets with get_google_spreadsheet_schema if you don't know"
"\nthe names or data structure. Make sure the values are in correct"
""" columns (needs to be ordered the same as in the sample).
Strictly adhere to the schema."""
)
openai_func_spec = convert_to_openai_function(tool)
assert isinstance(
openai_func_spec, dict
), "openai_func_spec should be a dictionary."
assert set(openai_func_spec.keys()) == {
"description",
"name",
"parameters",
}, "Top-level keys mismatch."
assert openai_func_spec["description"] == tool.description
assert openai_func_spec["name"] == tool.name
assert isinstance(
openai_func_spec["parameters"], dict
), "Parameters should be a dictionary."
params = openai_func_spec["parameters"]
assert set(params.keys()) == {
"type",
"properties",
"required",
}, "Parameters keys mismatch."
assert params["type"] == "object", "`type` in parameters should be 'object'."
assert isinstance(
params["properties"], dict
), "`properties` should be a dictionary."
assert isinstance(params["required"], list), "`required` should be a list."
assert set(params["required"]) == {
"sheet",
"rows_to_add",
}, "Required fields mismatch."
assert set(params["properties"].keys()) == {"sheet", "rows_to_add"}
desc = "The columns that make up the row"
expected = {
"description": "the rows to be added to the sheet",
"allOf": [
{
"title": "Rows To Add",
"type": "object",
"properties": {
"rows": {
"title": "Rows",
"description": "The rows that need to be added",
"type": "array",
"items": {
"title": "Row",
"type": "object",
"properties": {
"columns": {
"title": "Columns",
"description": desc,
"type": "array",
"items": {"type": "string"},
}
},
"required": ["columns"],
},
}
},
"required": ["rows"],
}
],
}
assert params["properties"]["rows_to_add"] == expectedThis test verifies that the parameters are correctly extracted and structured according to the OpenAPI specification [1][2]. |
Beta Was this translation helpful? Give feedback.
-
|
In def get_param_fields(docs: dict) -> dict: we use dictionary keys such as schema inside params which might not be present in every openapi scehma. Can we use some tested function which works on all kinds of specs from langchain to get the parameters and their types from openapi specification |
Beta Was this translation helpful? Give feedback.
-
|
@dosu how can I convert structured tool to Openai function? Is there a need to do so for openai function calling? |
Beta Was this translation helpful? Give feedback.
-
|
The error "cannot instantiate BasePromptTemplate with format methods" occurs because You can use from langchain_core.prompts.chat import ChatPromptTemplate
def create_openapi_endpoint_chain_with_custom_requester(
operation: APIOperation,
llm: BaseLanguageModel,
requests: Optional[Requests] = None,
verbose: bool = False,
return_intermediate_steps: bool = False,
**kwargs: Any,
) -> OpenAPIEndpointChain:
# Example usage of ChatPromptTemplate instead of BasePromptTemplate
prompt_template = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant."),
MessagesPlaceholder("history"),
("human", "{question}")
])
custom_request_chain = CustomAPIRequesterChain(llm=llm, prompt=prompt_template)
return OpenAPIEndpointChain(
api_request_chain=custom_request_chain,
api_response_chain=None, # or your actual response chain
api_operation=operation,
requests=requests or Requests(),
param_mapping=_ParamMapping(
query_params=operation.query_params,
body_params=operation.body_params,
path_params=operation.path_params,
),
verbose=verbose,
return_intermediate_steps=return_intermediate_steps,
**kwargs,
)This modification ensures that you are using a concrete subclass ( |
Beta Was this translation helpful? Give feedback.
-
|
@dosu while using the code below I get this error: File "/Users/ekansh/zeta_global/git_repos/assistants-service/zh_assistants_service/llms/assistants/openai/api_actions_new.py", line 190, in create_structured_tool_from_llm_and_method Importsimport json from fastapi import HTTPException, status from langchain_community.chains.openapi.chain import OpenAPIEndpointChain from zh_assistants_service.api.v1.schema.api_action import APIActionSchema Type aliasesCallbacks = Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]] Logging setuplogger = logging.getLogger(name) Classesclass CustomAPIRequesterChain(LLMChain): Functionsdef _get_field_type(schema: Dict[str, Any]) -> Any: def get_param_fields(docs: Dict[str, Any]) -> Dict[str, Any]: def create_openapi_endpoint_chain_with_custom_requester( def create_structured_tool_from_open_api_endpoint_chain( def create_structured_tool_from_llm_and_method( Patch the NLAToolNLATool.from_open_api_endpoint_chain = ( def convert_api_actions_into_tools( def create_requests_with_auth(authentication) -> Requests: |
Beta Was this translation helpful? Give feedback.
-
|
The error "value is not a valid dict" occurs because the Here is how you can modify your code to correctly pass the
from langchain_core.prompts.chat import ChatPromptTemplate, MessagesPlaceholder
def create_openapi_endpoint_chain_with_custom_requester(
operation: APIOperation,
llm: BaseLanguageModel,
requests: Optional[Requests] = None,
verbose: bool = False,
return_intermediate_steps: bool = False,
**kwargs: Any,
) -> OpenAPIEndpointChain:
# Example usage of ChatPromptTemplate instead of BasePromptTemplate
prompt_template = ChatPromptTemplate.from_messages([
("system", "You are a helpful assistant."),
MessagesPlaceholder("history"),
("human", "{question}")
])
# Convert the ChatPromptTemplate to a dictionary
prompt_dict = prompt_template.dict()
custom_request_chain = CustomAPIRequesterChain(llm=llm, prompt=prompt_dict)
return OpenAPIEndpointChain(
api_request_chain=custom_request_chain,
api_response_chain=None,
api_operation=operation,
requests=requests or Requests(),
param_mapping=_ParamMapping(
query_params=operation.query_params,
body_params=operation.body_params,
path_params=operation.path_params,
),
verbose=verbose,
return_intermediate_steps=return_intermediate_steps,
**kwargs,
)
from langchain.chains.llm import LLMChain
from langchain_core.language_models import BaseLanguageModel
from langchain_core.prompts import BasePromptTemplate
from typing import Any, Dict, Optional, Union, List
from langchain_core.callbacks import BaseCallbackHandler, BaseCallbackManager
# Type aliases
Callbacks = Optional[Union[List[BaseCallbackHandler], BaseCallbackManager]]
class CustomAPIRequesterChain(LLMChain):
def predict_and_parse(self, instructions: str, callbacks: Callbacks) -> str:
# Custom implementation that bypasses the original predict_and_parse method
return instructions # or any other logic you want to implement
def create_structured_tool_from_open_api_endpoint_chain(
chain: OpenAPIEndpointChain, api_title: str
) -> StructuredTool:
expanded_name = f'{api_title.replace(" ", "_")}-{chain.api_operation.operation_id}'
description = (
f"I'm an AI from {api_title}. Instruct what you want,"
" and I'll assist via an API with description:"
f" {chain.api_operation.description}"
)
def _get_structured_tool(
endpoint: str, docs: Dict[str, Any], tools_args: Dict[str, Any]
) -> StructuredTool:
fields = get_param_fields(docs)
DynamicToolInputSchema = create_model("DynamicToolInputSchema", **fields)
def dynamic_func(input: Union[str, Dict[str, Any], List[Any], Any]) -> Any:
if isinstance(input, dict):
kwargs = input
elif isinstance(input, list):
kwargs = {"args": input}
elif isinstance(input, str):
kwargs = {"instructions": input}
else:
kwargs = {"instructions": str(input)}
# Remove non-API related keys
for key in ["run_name", "callbacks", "max_concurrency"]:
kwargs.pop(key, None)
return chain.run(**kwargs)
dynamic_func.__name__ = tools_args["name"]
dynamic_func.__doc__ = tools_args["description"]
return StructuredTool(
func=dynamic_func,
args_schema=DynamicToolInputSchema,
**tools_args,
)
# Extract the input schema from the operation
docs = chain.api_operation.docs # Assuming docs are part of the api_operation
tools_args = {
"name": expanded_name,
"description": description,
}
return _get_structured_tool(chain.api_operation.path, docs, tools_args)
def create_structured_tool_from_llm_and_method(
llm: BaseLanguageModel,
path: str,
method: str,
spec: OpenAPISpec,
requests: Optional[Requests] = None,
verbose: bool = False,
return_intermediate_steps: bool = False,
**kwargs: Any,
) -> StructuredTool:
api_operation = APIOperation.from_openapi_spec(spec, path, method)
chain = create_openapi_endpoint_chain_with_custom_requester(
api_operation,
llm,
requests=requests,
verbose=verbose,
return_intermediate_steps=return_intermediate_steps,
raw_response=True,
**kwargs,
)
return create_structured_tool_from_open_api_endpoint_chain(chain, spec.info.title)By converting the |
Beta Was this translation helpful? Give feedback.
-
|
@dosu can you show me the documentation and reference source which can help me understand why the dict format is needed for prompt_template in this case |
Beta Was this translation helpful? Give feedback.
-
|
The documentation and reference source that explain why the @classmethod
def from_template(
cls,
template: str,
*,
template_format: str = "f-string",
partial_variables: Optional[Dict[str, Any]] = None,
**kwargs: Any,
) -> PromptTemplate:
"""Load a prompt template from a template.
*Security warning*:
Prefer using `template_format="f-string"` instead of
`template_format="jinja2"`, or make sure to NEVER accept jinja2 templates
from untrusted sources as they may lead to arbitrary Python code execution.
As of LangChain 0.0.329, Jinja2 templates will be rendered using
Jinja2's SandboxedEnvironment by default. This sand-boxing should
be treated as a best-effort approach rather than a guarantee of security,
as it is an opt-out rather than opt-in approach.
Despite the sand-boxing, we recommend never using jinja2 templates
from untrusted sources.
Args:
template: The template to load.
template_format: The format of the template. Use `jinja2` for jinja2,
and `f-string` or None for f-strings.
Defaults to `f-string`.
partial_variables: A dictionary of variables that can be used to partially
fill in the template. For example, if the template is
`"{variable1} {variable2}"`, and `partial_variables` is
`{"variable1": "foo"}`, then the final prompt will be
`"foo {variable2}"`. Defaults to None.
kwargs: Any other arguments to pass to the prompt template.
Returns:
The prompt template loaded from the template.
"""
input_variables = get_template_variables(template, template_format)
_partial_variables = partial_variables or {}
if _partial_variables:
input_variables = [
var for var in input_variables if var not in _partial_variables
]
return cls(
input_variables=input_variables,
template=template,
template_format=template_format, # type: ignore[arg-type]
partial_variables=_partial_variables,
**kwargs,
)This method shows that Additionally, the unit tests in def test_prompt_from_template_with_partial_variables() -> None:
"""Test prompts can be constructed from a template with partial variables."""
# given
template = "This is a {foo} test {bar}."
partial_variables = {"bar": "baz"}
# when
prompt = PromptTemplate.from_template(template, partial_variables=partial_variables)
# then
expected_prompt = PromptTemplate(
template=template,
input_variables=["foo"],
partial_variables=partial_variables,
)
assert prompt == expected_promptThis test demonstrates that |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
-
Checked other resources
Commit to Help
Example Code
Description
JSON payload from OpenAI is altered by the APIRequesterChain. Specifically predict_and_parse method. How can we skip the usage of predict_and_parse in
System Info
langchain==0.2.12
langchain-community==0.2.11
langchain-core==0.2.29
langchain-openai==0.1.20
langchain-text-splitters==0.2.2
platform: mac
python: 3.10.2
Beta Was this translation helpful? Give feedback.
All reactions