langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/chains/openai_functions/citation_fuzzy_match.py

@@ -45,6 +45,14 @@ class FactWithEvidence(BaseModel):
             yield from s.spans()
 
     def get_spans(self, context: str) -> Iterator[str]:
+        """Get spans of the substring quote in the context.
+
+        Args:
+            context: The context in which to find the spans of the substring quote.
+
+        Returns:
+            An iterator over the spans of the substring quote in the context.
+        """
         for quote in self.substring_quote:
             yield from self._get_span(quote, context)
 
@@ -86,25 +94,25 @@ def create_citation_fuzzy_match_runnable(llm: BaseChatModel) -> Runnable:
 
     Returns:
         Runnable that can be used to answer questions with citations.
+
     """
     if llm.bind_tools is BaseChatModel.bind_tools:
-        raise ValueError(
-            "Language model must implement bind_tools to use this function."
-        )
+        msg = "Language model must implement bind_tools to use this function."
+        raise ValueError(msg)
     prompt = ChatPromptTemplate(
         [
             SystemMessage(
                 "You are a world class algorithm to answer "
-                "questions with correct and exact citations."
+                "questions with correct and exact citations.",
             ),
             HumanMessagePromptTemplate.from_template(
                 "Answer question using the following context."
                 "\n\n{context}"
                 "\n\nQuestion: {question}"
                 "\n\nTips: Make sure to cite your sources, "
-                "and use the exact words from the context."
+                "and use the exact words from the context.",
             ),
-        ]
+        ],
     )
     return prompt | llm.with_structured_output(QuestionAnswer)
 
@@ -124,7 +132,10 @@ def create_citation_fuzzy_match_chain(llm: BaseLanguageModel) -> LLMChain:
         Chain (LLMChain) that can be used to answer questions with citations.
     """
     output_parser = PydanticOutputFunctionsParser(pydantic_schema=QuestionAnswer)
-    schema = QuestionAnswer.schema()
+    if hasattr(QuestionAnswer, "model_json_schema"):
+        schema = QuestionAnswer.model_json_schema()
+    else:
+        schema = QuestionAnswer.schema()
     function = {
         "name": schema["title"],
         "description": schema["description"],
@@ -136,7 +147,7 @@ def create_citation_fuzzy_match_chain(llm: BaseLanguageModel) -> LLMChain:
             content=(
                 "You are a world class algorithm to answer "
                 "questions with correct and exact citations."
-            )
+            ),
         ),
         HumanMessage(content="Answer question using the following context"),
         HumanMessagePromptTemplate.from_template("{context}"),
@@ -145,15 +156,14 @@ def create_citation_fuzzy_match_chain(llm: BaseLanguageModel) -> LLMChain:
             content=(
                 "Tips: Make sure to cite your sources, "
                 "and use the exact words from the context."
-            )
+            ),
         ),
     ]
     prompt = ChatPromptTemplate(messages=messages)  # type: ignore[arg-type]
 
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
     )
-    return chain

langchain/chains/openai_functions/extraction.py

@@ -25,7 +25,7 @@ def _get_extraction_function(entity_schema: dict) -> dict:
         "parameters": {
             "type": "object",
             "properties": {
-                "info": {"type": "array", "items": _convert_schema(entity_schema)}
+                "info": {"type": "array", "items": _convert_schema(entity_schema)},
             },
             "required": ["info"],
         },
@@ -63,18 +63,18 @@ Passage:
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -84,7 +84,7 @@ def create_extraction_chain(
     llm: BaseLanguageModel,
     prompt: Optional[BasePromptTemplate] = None,
     tags: Optional[list[str]] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> Chain:
     """Creates a chain that extracts information from a passage.
 
@@ -103,7 +103,7 @@ def create_extraction_chain(
     extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
     output_parser = JsonKeyOutputFunctionsParser(key_name="info")
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=extraction_prompt,
         llm_kwargs=llm_kwargs,
@@ -111,7 +111,6 @@ def create_extraction_chain(
         tags=tags,
         verbose=verbose,
     )
-    return chain
 
 
 @deprecated(
@@ -133,18 +132,18 @@ def create_extraction_chain(
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -153,7 +152,7 @@ def create_extraction_chain_pydantic(
     pydantic_schema: Any,
     llm: BaseLanguageModel,
     prompt: Optional[BasePromptTemplate] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> Chain:
     """Creates a chain that extracts information from a passage using pydantic schema.
 
@@ -178,20 +177,21 @@ def create_extraction_chain_pydantic(
         openai_schema = pydantic_schema.schema()
 
     openai_schema = _resolve_schema_references(
-        openai_schema, openai_schema.get("definitions", {})
+        openai_schema,
+        openai_schema.get("definitions", {}),
     )
 
     function = _get_extraction_function(openai_schema)
     extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
     output_parser = PydanticAttrOutputFunctionsParser(
-        pydantic_schema=PydanticSchema, attr_name="info"
+        pydantic_schema=PydanticSchema,
+        attr_name="info",
     )
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=extraction_prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         verbose=verbose,
     )
-    return chain

langchain/chains/openai_functions/openapi.py

@@ -13,6 +13,7 @@ from langchain_core.output_parsers.openai_functions import JsonOutputFunctionsPa
 from langchain_core.prompts import BasePromptTemplate, ChatPromptTemplate
 from langchain_core.utils.input import get_colored_text
 from requests import Response
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 from langchain.chains.llm import LLMChain
@@ -23,14 +24,6 @@ if TYPE_CHECKING:
     from openapi_pydantic import Parameter
 
 
-def _get_description(o: Any, prefer_short: bool) -> Optional[str]:
-    summary = getattr(o, "summary", None)
-    description = getattr(o, "description", None)
-    if prefer_short:
-        return summary or description
-    return description or summary
-
-
 def _format_url(url: str, path_params: dict) -> str:
     expected_path_param = re.findall(r"{(.*?)}", url)
     new_params = {}
@@ -59,13 +52,12 @@ def _format_url(url: str, path_params: dict) -> str:
                 sep = ","
                 new_val = ""
             new_val += sep.join(kv_strs)
+        elif param[0] == ".":
+            new_val = f".{val}"
+        elif param[0] == ";":
+            new_val = f";{clean_param}={val}"
         else:
-            if param[0] == ".":
-                new_val = f".{val}"
-            elif param[0] == ";":
-                new_val = f";{clean_param}={val}"
-            else:
-                new_val = val
+            new_val = val
         new_params[param] = new_val
     return url.format(**new_params)
 
@@ -77,7 +69,7 @@ def _openapi_params_to_json_schema(params: list[Parameter], spec: OpenAPISpec) -
         if p.param_schema:
             schema = spec.get_schema(p.param_schema)
         else:
-            media_type_schema = list(p.content.values())[0].media_type_schema
+            media_type_schema = next(iter(p.content.values())).media_type_schema
             schema = spec.get_schema(media_type_schema)
         if p.description and not schema.description:
             schema.description = p.description
@@ -102,11 +94,12 @@ def openapi_spec_to_openai_fn(
     """
     try:
         from langchain_community.tools import APIOperation
-    except ImportError:
-        raise ImportError(
+    except ImportError as e:
+        msg = (
             "Could not import langchain_community.tools. "
             "Please install it with `pip install langchain-community`."
         )
+        raise ImportError(msg) from e
 
     if not spec.paths:
         return [], lambda: None
@@ -134,7 +127,8 @@ def openapi_spec_to_openai_fn(
             for param_loc, arg_name in param_loc_to_arg_name.items():
                 if params_by_type[param_loc]:
                     request_args[arg_name] = _openapi_params_to_json_schema(
-                        params_by_type[param_loc], spec
+                        params_by_type[param_loc],
+                        spec,
                     )
             request_body = spec.get_request_body_for_operation(op)
             # TODO: Support more MIME types.
@@ -144,10 +138,10 @@ def openapi_spec_to_openai_fn(
                     if media_type_object.media_type_schema:
                         schema = spec.get_schema(media_type_object.media_type_schema)
                         media_types[media_type] = json.loads(
-                            schema.json(exclude_none=True)
+                            schema.json(exclude_none=True),
                         )
                 if len(media_types) == 1:
-                    media_type, schema_dict = list(media_types.items())[0]
+                    media_type, schema_dict = next(iter(media_types.items()))
                     key = "json" if media_type == "application/json" else "data"
                     request_args[key] = schema_dict
                 elif len(media_types) > 1:
@@ -173,6 +167,7 @@ def openapi_spec_to_openai_fn(
         fn_args: dict,
         headers: Optional[dict] = None,
         params: Optional[dict] = None,
+        timeout: Optional[int] = 30,
         **kwargs: Any,
     ) -> Any:
         method = _name_to_call_map[name]["method"]
@@ -192,7 +187,7 @@ def openapi_spec_to_openai_fn(
                 _kwargs["params"].update(params)
             else:
                 _kwargs["params"] = params
-        return requests.request(method, url, **_kwargs)
+        return requests.request(method, url, **_kwargs, timeout=timeout)
 
     return functions, default_call_api
 
@@ -208,10 +203,12 @@ class SimpleRequestChain(Chain):
     """Key to use for the input of the request."""
 
     @property
+    @override
     def input_keys(self) -> list[str]:
         return [self.input_key]
 
     @property
+    @override
     def output_keys(self) -> list[str]:
         return [self.output_key]
 
@@ -229,11 +226,11 @@ class SimpleRequestChain(Chain):
         _text = f"Calling endpoint {_pretty_name} with arguments:\n" + _pretty_args
         _run_manager.on_text(_text)
         api_response: Response = self.request_method(name, args)
-        if api_response.status_code != 200:
+        if api_response.status_code != requests.codes.ok:
             response = (
                 f"{api_response.status_code}: {api_response.reason}"
-                + f"\nFor {name} "
-                + f"Called with args: {args.get('params', '')}"
+                f"\nFor {name} "
+                f"Called with args: {args.get('params', '')}"
             )
         else:
             try:
@@ -248,7 +245,7 @@ class SimpleRequestChain(Chain):
     message=(
         "This function is deprecated and will be removed in langchain 1.0. "
         "See API reference for replacement: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.openapi.get_openapi_chain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.openapi.get_openapi_chain.html"
     ),
     removal="1.0",
 )
@@ -258,7 +255,7 @@ def get_openapi_chain(
     prompt: Optional[BasePromptTemplate] = None,
     request_chain: Optional[Chain] = None,
     llm_chain_kwargs: Optional[dict] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
     headers: Optional[dict] = None,
     params: Optional[dict] = None,
     **kwargs: Any,
@@ -348,14 +345,16 @@ def get_openapi_chain(
             `ChatOpenAI(model="gpt-3.5-turbo-0613")`.
         prompt: Main prompt template to use.
         request_chain: Chain for taking the functions output and executing the request.
+
     """  # noqa: E501
     try:
         from langchain_community.utilities.openapi import OpenAPISpec
     except ImportError as e:
-        raise ImportError(
+        msg = (
             "Could not import langchain_community.utilities.openapi. "
             "Please install it with `pip install langchain-community`."
-        ) from e
+        )
+        raise ImportError(msg) from e
     if isinstance(spec, str):
         for conversion in (
             OpenAPISpec.from_url,
@@ -365,21 +364,23 @@ def get_openapi_chain(
             try:
                 spec = conversion(spec)
                 break
-            except ImportError as e:
-                raise e
-            except Exception:
+            except ImportError:
+                raise
+            except Exception:  # noqa: S110
                 pass
         if isinstance(spec, str):
-            raise ValueError(f"Unable to parse spec from source {spec}")
+            msg = f"Unable to parse spec from source {spec}"
+            raise ValueError(msg)  # noqa: TRY004
     openai_fns, call_api_fn = openapi_spec_to_openai_fn(spec)
     if not llm:
-        raise ValueError(
+        msg = (
             "Must provide an LLM for this chain.For example,\n"
             "from langchain_openai import ChatOpenAI\n"
             "llm = ChatOpenAI()\n"
         )
+        raise ValueError(msg)
     prompt = prompt or ChatPromptTemplate.from_template(
-        "Use the provided API's to respond to this user query:\n\n{query}"
+        "Use the provided API's to respond to this user query:\n\n{query}",
     )
     llm_chain = LLMChain(
         llm=llm,
@@ -392,7 +393,10 @@ def get_openapi_chain(
     )
     request_chain = request_chain or SimpleRequestChain(
         request_method=lambda name, args: call_api_fn(
-            name, args, headers=headers, params=params
+            name,
+            args,
+            headers=headers,
+            params=params,
         ),
         verbose=verbose,
     )

langchain/chains/openai_functions/qa_with_structure.py

@@ -22,7 +22,8 @@ class AnswerWithSources(BaseModel):
 
     answer: str = Field(..., description="Answer to the question that was asked")
     sources: list[str] = Field(
-        ..., description="List of sources used to answer the question"
+        ...,
+        description="List of sources used to answer the question",
     )
 
 
@@ -32,7 +33,7 @@ class AnswerWithSources(BaseModel):
     message=(
         "This function is deprecated. Refer to this guide on retrieval and question "
         "answering with structured responses: "
-        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"  # noqa: E501
+        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"
     ),
 )
 def create_qa_with_structure_chain(
@@ -40,7 +41,7 @@ def create_qa_with_structure_chain(
     schema: Union[dict, type[BaseModel]],
     output_parser: str = "base",
     prompt: Optional[Union[PromptTemplate, ChatPromptTemplate]] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> LLMChain:
     """Create a question answering chain that returns an answer with sources
      based on schema.
@@ -57,27 +58,29 @@ def create_qa_with_structure_chain(
     """
     if output_parser == "pydantic":
         if not (isinstance(schema, type) and is_basemodel_subclass(schema)):
-            raise ValueError(
+            msg = (
                 "Must provide a pydantic class for schema when output_parser is "
                 "'pydantic'."
             )
+            raise ValueError(msg)
         _output_parser: BaseLLMOutputParser = PydanticOutputFunctionsParser(
-            pydantic_schema=schema
+            pydantic_schema=schema,
         )
     elif output_parser == "base":
         _output_parser = OutputFunctionsParser()
     else:
-        raise ValueError(
+        msg = (
             f"Got unexpected output_parser: {output_parser}. "
             f"Should be one of `pydantic` or `base`."
         )
+        raise ValueError(msg)
     if isinstance(schema, type) and is_basemodel_subclass(schema):
         if hasattr(schema, "model_json_schema"):
-            schema_dict = cast(dict, schema.model_json_schema())
+            schema_dict = cast("dict", schema.model_json_schema())
         else:
-            schema_dict = cast(dict, schema.schema())
+            schema_dict = cast("dict", schema.schema())
     else:
-        schema_dict = cast(dict, schema)
+        schema_dict = cast("dict", schema)
     function = {
         "name": schema_dict["title"],
         "description": schema_dict["description"],
@@ -89,7 +92,7 @@ def create_qa_with_structure_chain(
             content=(
                 "You are a world class algorithm to answer "
                 "questions in a specific format."
-            )
+            ),
         ),
         HumanMessage(content="Answer question using the following context"),
         HumanMessagePromptTemplate.from_template("{context}"),
@@ -98,14 +101,13 @@ def create_qa_with_structure_chain(
     ]
     prompt = prompt or ChatPromptTemplate(messages=messages)  # type: ignore[arg-type]
 
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=_output_parser,
         verbose=verbose,
     )
-    return chain
 
 
 @deprecated(
@@ -114,11 +116,13 @@ def create_qa_with_structure_chain(
     message=(
         "This function is deprecated. Refer to this guide on retrieval and question "
         "answering with sources: "
-        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"  # noqa: E501
+        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"
     ),
 )
 def create_qa_with_sources_chain(
-    llm: BaseLanguageModel, verbose: bool = False, **kwargs: Any
+    llm: BaseLanguageModel,
+    verbose: bool = False,  # noqa: FBT001,FBT002
+    **kwargs: Any,
 ) -> LLMChain:
     """Create a question answering chain that returns an answer with sources.
 
@@ -131,5 +135,8 @@ def create_qa_with_sources_chain(
         Chain (LLMChain) that can be used to answer questions with citations.
     """
     return create_qa_with_structure_chain(
-        llm, AnswerWithSources, verbose=verbose, **kwargs
+        llm,
+        AnswerWithSources,
+        verbose=verbose,
+        **kwargs,
     )

langchain/chains/openai_functions/tagging.py

@@ -86,19 +86,19 @@ def create_tagging_chain(
 
     Returns:
         Chain (LLMChain) that can be used to extract information from a passage.
+
     """
     function = _get_tagging_function(schema)
     prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
     output_parser = JsonOutputFunctionsParser()
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         **kwargs,
     )
-    return chain
 
 
 @deprecated(
@@ -155,6 +155,7 @@ def create_tagging_chain_pydantic(
 
     Returns:
         Chain (LLMChain) that can be used to extract information from a passage.
+
     """
     if hasattr(pydantic_schema, "model_json_schema"):
         openai_schema = pydantic_schema.model_json_schema()
@@ -164,11 +165,10 @@ def create_tagging_chain_pydantic(
     prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
     output_parser = PydanticOutputFunctionsParser(pydantic_schema=pydantic_schema)
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         **kwargs,
     )
-    return chain

langchain/chains/openai_tools/extraction.py

@@ -34,18 +34,18 @@ If a property is not present and is not required in the function parameters, do
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -71,10 +71,9 @@ def create_extraction_chain_pydantic(
         [
             ("system", system_message),
             ("user", "{input}"),
-        ]
+        ],
     )
     functions = [convert_pydantic_to_openai_function(p) for p in pydantic_schemas]
     tools = [{"type": "function", "function": d} for d in functions]
     model = llm.bind(tools=tools)
-    chain = prompt | model | PydanticToolsParser(tools=pydantic_schemas)
-    return chain
+    return prompt | model | PydanticToolsParser(tools=pydantic_schemas)

langchain/chains/qa_generation/base.py

@@ -9,6 +9,7 @@ from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts import BasePromptTemplate
 from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
 from pydantic import Field
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 from langchain.chains.llm import LLMChain
@@ -19,7 +20,7 @@ from langchain.chains.qa_generation.prompt import PROMPT_SELECTOR
     since="0.2.7",
     alternative=(
         "example in API reference with more detail: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html"
     ),
     removal="1.0",
 )
@@ -61,12 +62,13 @@ class QAGenerationChain(Chain):
                     split_text | RunnableEach(bound=prompt | llm | JsonOutputParser())
                 )
             )
+
     """
 
     llm_chain: LLMChain
     """LLM Chain that generates responses from user input and context."""
     text_splitter: TextSplitter = Field(
-        default=RecursiveCharacterTextSplitter(chunk_overlap=500)
+        default=RecursiveCharacterTextSplitter(chunk_overlap=500),
     )
     """Text splitter that splits the input into chunks."""
     input_key: str = "text"
@@ -103,10 +105,12 @@ class QAGenerationChain(Chain):
         raise NotImplementedError
 
     @property
+    @override
     def input_keys(self) -> list[str]:
         return [self.input_key]
 
     @property
+    @override
     def output_keys(self) -> list[str]:
         return [self.output_key]
 
@@ -117,7 +121,8 @@ class QAGenerationChain(Chain):
     ) -> dict[str, list]:
         docs = self.text_splitter.create_documents([inputs[self.input_key]])
         results = self.llm_chain.generate(
-            [{"text": d.page_content} for d in docs], run_manager=run_manager
+            [{"text": d.page_content} for d in docs],
+            run_manager=run_manager,
         )
         qa = [json.loads(res[0].text) for res in results.generations]
         return {self.output_key: qa}