How do I type the return of a runnable?

[avalatea]

A function can return a runnable. For example:

def create_qa_chain(query: str) -> Runnable

However, it is hard to tell what kind of runnable it is. Does it accept an int? A string? A dict? And what does it return? Runnable should work like the Callable typing. How do I do this? Give me an example (that I can run) to check that it works.

[dosubot[bot]]

Hi @avalatea! I'm here to help you with any bugs, questions, or contributions you have. Let me know how I can assist you.

To type the return of a Runnable in a way that specifies both the input and output types, you can use Python's type annotations. While Runnable itself is a generic interface, you can define a subclass or use a type alias to specify the input and output types explicitly. Here's an example of how you might define and use a Runnable with specific input and output types:

from typing import TypeVar, Generic, Dict
from langchain_core.runnables.base import Runnable

# Define type variables for input and output types
InputType = TypeVar('InputType')
OutputType = TypeVar('OutputType')

# Create a generic Runnable class with specified input and output types
class TypedRunnable(Runnable, Generic[InputType, OutputType]):
    def __init__(self, input_type: InputType, output_type: OutputType):
        self.input_type = input_type
        self.output_type = output_type

    def invoke(self, input_data: InputType) -> OutputType:
        # Example implementation
        return self.output_type

# Example function returning a TypedRunnable
def create_qa_chain(query: str) -> TypedRunnable[Dict[str, str], str]:
    # Here, the input is a dictionary and the output is a string
    return TypedRunnable(input_type={"question": query}, output_type="answer")

# Usage
qa_chain = create_qa_chain("What is the capital of France?")
result = qa_chain.invoke({"question": "What is the capital of France?"})
print(result)  # Output: "answer"

In this example, TypedRunnable is a subclass of Runnable that uses Python's generics to specify the input and output types. The create_qa_chain function returns a TypedRunnable that accepts a dictionary as input and returns a string. This approach allows you to clearly define and enforce the types for your Runnable instances.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[avalatea]

This is too difficult to use and implement, and possibly risky too. Can langchain already do this?

def create_qa_chain(query: str) -> Runnable[[int, str], str]

[dosubot[bot]]

LangChain provides a built-in way to specify input and output types for Runnables, similar to Python's Callable typing. You can use the with_types method to override the inferred input and output types for a Runnable. Here's an example of how you can achieve this:

from langchain_core.runnables.base import Runnable

# Example Runnable class
class MyRunnable(Runnable):
    def invoke(self, input_data: int) -> str:
        # Example implementation
        return str(input_data)

# Function returning a Runnable with specified input and output types
def create_qa_chain(query: str) -> Runnable:
    runnable = MyRunnable()
    # Specify the input and output types using with_types
    return runnable.with_types(input_type=int, output_type=str)

# Usage
qa_chain = create_qa_chain("example query")
result = qa_chain.invoke(42)
print(result)  # Output: "42"

In this example, create_qa_chain returns a Runnable that accepts an int as input and returns a str. The with_types method is used to specify these types explicitly ^[1][2].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[avalatea]

But this is not typing the runnable, per se. This is hard enforcing?