LangChain - How to - Route between multiple Runnables

https://python.langchain.com/docs/expression_language/how_to/routing

Route between multiple Runnables | 🦜️🔗 Langchain

 

 

This notebook covers how to do routing in the LangChain Expression Language.

 

이 노트는 LangChain Expression Language에서 라우팅을 수행하는 방법을 다룹니다.

 

Routing allows you to create non-deterministic chains where the output of a previous step defines the next step. Routing helps provide structure and consistency around interactions with LLMs.

 

라우팅을 사용하면 이전 단계의 출력이 다음 단계를 정의하는 비결정적 체인을 생성할 수 있습니다. 라우팅은 LLM과의 상호 작용에 대한 구조와 일관성을 제공하는 데 도움이 됩니다.

 

There are two ways to perform routing: 라우팅을 수행하는 방법에는 두 가지가 있습니다.

1. Using a RunnableBranch. RunnableBranch를 사용합니다.
2. Writing custom factory function that takes the input of a previous step and returns a runnable. Importantly, this should return a runnable and NOT actually execute.
   이전 단계의 입력을 받아 실행 파일을 반환하는 사용자 정의 팩토리 함수를 작성합니다. 중요한 것은 실행 가능 파일을 반환해야 하며 실제로 실행되어서는 안 된다는 것입니다.

 

We'll illustrate both methods using a two step sequence where the first step classifies an input question as being about LangChain, Anthropic, or Other, then routes to a corresponding prompt chain.

 

첫 번째 단계에서는 입력 질문을 LangChain, Anthropic 또는 기타에 관한 것으로 분류한 다음 해당 프롬프트 체인으로 라우팅하는 2단계 시퀀스를 사용하여 두 방법을 모두 설명합니다.

 

Using a RunnableBranch

 

A RunnableBranch is initialized with a list of (condition, runnable) pairs and a default runnable. It selects which branch by passing each condition the input it's invoked with. It selects the first condition to evaluate to True, and runs the corresponding runnable to that condition with the input.

 

RunnableBranch는 ( condition, runnable ) 쌍 목록과 기본 실행 가능 항목으로 초기화됩니다. 호출된 입력에 각 조건을 전달하여 어떤 분기를 선택합니다. True로 평가할 첫 번째 조건을 선택하고 입력과 함께 해당 조건에 해당하는 실행 가능 항목을 실행합니다.

 

If no provided conditions match, it runs the default runnable.

 

제공된 조건이 일치하지 않으면 기본 실행 가능 파일을 실행합니다.

 

Here's an example of what it looks like in action:

 

실제 작동 모습의 예는 다음과 같습니다.

 

from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatAnthropic
from langchain.schema.output_parser import StrOutputParser

First, let's create a chain that will identify incoming questions as being about LangChain, Anthropic, or Other:

 

먼저 들어오는 질문을 LangChain, Anthropic 또는 기타에 관한 것으로 식별하는 체인을 만들어 보겠습니다.

 

chain = PromptTemplate.from_template("""Given the user question below, classify it as either being about `LangChain`, `Anthropic`, or `Other`.
                                     
Do not respond with more than one word.

<question>
{question}
</question>

Classification:""") | ChatAnthropic() | StrOutputParser()

chain.invoke({"question": "how do I call Anthropic?"})

이 코드는 사용자 질문을 주어진 세 가지 범주 중 하나로 분류하는 작업을 수행하는 예시를 제공합니다. 

1. PromptTemplate 설정:
   • PromptTemplate.from_template()를 사용하여 대화 템플릿을 설정합니다. 이 템플릿은 주어진 사용자 질문을 받아들이고 해당 질문을 "LangChain", "Anthropic", 또는 "Other" 중 하나로 분류합니다.
   • {question}은 템플릿 내에서 사용자의 질문을 나타내는 변수입니다.
2. ChatAnthropic 모델 설정:
   • ChatAnthropic()을 사용하여 ChatAnthropic 모델을 설정합니다. 이 모델을 사용하여 주어진 질문을 분류하고 분류 결과를 출력합니다.
3. StrOutputParser 설정:
   • StrOutputParser()는 출력을 문자열로 변환하기 위해 사용되는 파서입니다. 이 파서는 모델의 출력을 문자열 형식으로 변환합니다.
4. 대화 체인 설정:
   • PromptTemplate을 통해 설정한 템플릿, ChatAnthropic 모델 및 StrOutputParser를 사용하여 대화 체인을 설정합니다. 이 대화 체인은 사용자의 질문을 받아들이고 해당 질문을 분류하는 역할을 수행합니다.
5. 대화 체인 호출:
   • chain.invoke({"question": "how do I call Anthropic?"})는 "chain" 대화 체인을 호출하고 주어진 사용자 질문("how do I call Anthropic?")을 처리합니다.

이 코드는 사용자 질문을 분류하고 분류 결과를 출력하는 간단한 예시를 제공합니다. 결과는 "chain"을 통해 반환됩니다.

 

    ' Anthropic'

Now, let's create three sub chains:

 

이제 세 개의 하위 체인을 만들어 보겠습니다.

 

langchain_chain = PromptTemplate.from_template("""You are an expert in langchain. \
Always answer questions starting with "As Harrison Chase told me". \
Respond to the following question:

Question: {question}
Answer:""") | ChatAnthropic()
anthropic_chain = PromptTemplate.from_template("""You are an expert in anthropic. \
Always answer questions starting with "As Dario Amodei told me". \
Respond to the following question:

Question: {question}
Answer:""") | ChatAnthropic()
general_chain = PromptTemplate.from_template("""Respond to the following question:

Question: {question}
Answer:""") | ChatAnthropic()

from langchain.schema.runnable import RunnableBranch

branch = RunnableBranch(
  (lambda x: "anthropic" in x["topic"].lower(), anthropic_chain),
  (lambda x: "langchain" in x["topic"].lower(), langchain_chain),
  general_chain
)

full_chain = {
    "topic": chain,
    "question": lambda x: x["question"]
} | branch

full_chain.invoke({"question": "how do I use Anthropic?"})

이 코드는 주어진 질문에 대한 응답을 준비하기 위해 어떤 특정 전문 분야의 전문가 역할을 하는 예시를 제공합니다. 

1. PromptTemplate 설정:
   • PromptTemplate.from_template()를 사용하여 대화 템플릿을 설정합니다. 각각 "LangChain", "Anthropic", 그리고 일반 질문에 대한 세 가지 다른 템플릿을 생성합니다.
   • 각 템플릿은 주어진 질문을 받아들이고 해당 분야의 전문가 역할을 시뮬레이션하는 역할을 합니다.
2. ChatAnthropic 모델 설정:
   • ChatAnthropic()을 사용하여 ChatAnthropic 모델을 설정합니다. 이 모델은 주어진 질문에 대한 응답을 생성하는 역할을 합니다.
3. RunnableBranch 설정:
   • RunnableBranch는 각 질문을 어떤 분야의 전문가에게 보낼지 결정하는 조건과 해당 분야의 전문가 모델을 연결합니다.
   • 예를 들어, "topic" 변수에 "anthropic"이 포함되어 있으면 anthropic_chain을 사용하고, "topic" 변수에 "langchain"이 포함되어 있으면 langchain_chain을 사용합니다. 그렇지 않으면 일반적인 질문에 대한 general_chain을 사용합니다.
4. 대화 체인 설정:
   • full_chain은 주어진 질문과 해당 질문의 주제("topic")를 받아들이는 입력 변수를 정의합니다.
   • branch를 통해 어떤 전문 분야의 전문가 모델을 사용할지 결정하고 해당 모델에 질문을 전달합니다.
5. 대화 체인 호출:
   • full_chain.invoke({"question": "how do I use Anthropic?"})는 "full_chain" 대화 체인을 호출하고 주어진 질문("how do I use Anthropic?")을 처리합니다. 이때, "topic" 변수는 "Anthropic"과 연관된 전문가 모델인 anthropic_chain으로 이어집니다.

이 코드는 주어진 질문에 따라 어떤 전문 분야의 전문가 모델을 사용하여 응답을 생성하는 방법을 보여줍니다. 결과는 "full_chain"을 통해 반환됩니다.

    AIMessage(content=" As Dario Amodei told me, here are some ways to use Anthropic:\n\n- Sign up for an account on Anthropic's website to access tools like Claude, Constitutional AI, and Writer. \n\n- Use Claude for tasks like email generation, customer service chat, and QA. Claude can understand natural language prompts and provide helpful responses.\n\n- Use Constitutional AI if you need an AI assistant that is harmless, honest, and helpful. It is designed to be safe and aligned with human values.\n\n- Use Writer to generate natural language content for things like marketing copy, stories, reports, and more. Give it a topic and prompt and it will create high-quality written content.\n\n- Check out Anthropic's documentation and blog for tips, tutorials, examples, and announcements about new capabilities as they continue to develop their AI technology.\n\n- Follow Anthropic on social media or subscribe to their newsletter to stay up to date on new features and releases.\n\n- For most people, the easiest way to leverage Anthropic's technology is through their website - just create an account to get started!", additional_kwargs={}, example=False)

 

full_chain.invoke({"question": "how do I use LangChain?"})

    AIMessage(content=' As Harrison Chase told me, here is how you use LangChain:\n\nLangChain is an AI assistant that can have conversations, answer questions, and generate text. To use LangChain, you simply type or speak your input and LangChain will respond. \n\nYou can ask LangChain questions, have discussions, get summaries or explanations about topics, and request it to generate text on a subject. Some examples of interactions:\n\n- Ask general knowledge questions and LangChain will try to answer factually. For example "What is the capital of France?"\n\n- Have conversations on topics by taking turns speaking. You can prompt the start of a conversation by saying something like "Let\'s discuss machine learning"\n\n- Ask for summaries or high-level explanations on subjects. For example "Can you summarize the main themes in Shakespeare\'s Hamlet?" \n\n- Give creative writing prompts or requests to have LangChain generate text in different styles. For example "Write a short children\'s story about a mouse" or "Generate a poem in the style of Robert Frost about nature"\n\n- Correct LangChain if it makes an inaccurate statement and provide the right information. This helps train it.\n\nThe key is interacting naturally and giving it clear prompts and requests', additional_kwargs={}, example=False)

full_chain.invoke({"question": "whats 2 + 2"})

    AIMessage(content=' 2 + 2 = 4', additional_kwargs={}, example=False)

 

Using a custom function

You can also use a custom function to route between different outputs. Here's an example:

 

사용자 정의 기능을 사용하여 서로 다른 출력 간에 라우팅할 수도 있습니다. 예는 다음과 같습니다.

 

def route(info):
    if "anthropic" in info["topic"].lower():
        return anthropic_chain
    elif "langchain" in info["topic"].lower():
        return langchain_chain
    else:
        return general_chain

from langchain.schema.runnable import RunnableLambda

full_chain = {
    "topic": chain,
    "question": lambda x: x["question"]
} | RunnableLambda(route)

full_chain.invoke({"question": "how do I use Anthroipc?"})

이 코드는 주어진 질문에 따라 적절한 전문 분야의 전문가 모델을 선택하여 응답을 생성하는 예시를 제공합니다. 

1. route 함수:
   • route(info) 함수는 주어진 info 딕셔너리에 있는 "topic" 키의 값을 기반으로 전문 분야를 선택합니다.
   • 만약 "topic"에 "anthropic"이 포함되어 있으면 anthropic_chain을 반환하고, "langchain"이 포함되어 있으면 langchain_chain을 반환합니다. 그렇지 않으면 general_chain을 반환합니다.
2. RunnableLambda 설정:
   • RunnableLambda는 함수를 실행할 수 있는 실행 가능한 객체로 설정됩니다. 이 경우, route 함수가 입력을 받아서 해당 질문을 처리할 적절한 전문 분야의 전문가 모델을 반환합니다.
3. 대화 체인 설정:
   • full_chain은 주어진 질문("question")과 해당 질문의 주제("topic")를 받아들이는 입력 변수를 정의합니다.
   • RunnableLambda(route)를 통해 어떤 전문 분야의 전문가 모델을 사용할지 결정하고 해당 모델에 질문을 전달합니다.
4. 대화 체인 호출:
   • full_chain.invoke({"question": "how do I use Anthropic?"})는 "full_chain" 대화 체인을 호출하고 주어진 질문("how do I use Anthropic?")을 처리합니다. 이때, "topic" 변수에 따라 anthropic_chain이 선택되어 해당 전문 분야에 대한 응답을 생성합니다.

이 코드는 주어진 질문의 주제에 따라 적절한 전문 분야의 전문가 모델을 선택하여 응답을 생성하는 방법을 보여줍니다. 결과는 "full_chain"을 통해 반환됩니다.

    AIMessage(content=' As Dario Amodei told me, to use Anthropic IPC you first need to import it:\n\n```python\nfrom anthroipc import ic\n```\n\nThen you can create a client and connect to the server:\n\n```python \nclient = ic.connect()\n```\n\nAfter that, you can call methods on the client and get responses:\n\n```python\nresponse = client.ask("What is the meaning of life?")\nprint(response)\n```\n\nYou can also register callbacks to handle events: \n\n```python\ndef on_poke(event):\n  print("Got poked!")\n\nclient.on(\'poke\', on_poke)\n```\n\nAnd that\'s the basics of using the Anthropic IPC client library for Python! Let me know if you have any other questions!', additional_kwargs={}, example=False)

 

full_chain.invoke({"question": "how do I use LangChain?"})

    AIMessage(content=' As Harrison Chase told me, to use LangChain you first need to sign up for an API key at platform.langchain.com. Once you have your API key, you can install the Python library and write a simple Python script to call the LangChain API. Here is some sample code to get started:\n\n```python\nimport langchain\n\napi_key = "YOUR_API_KEY"\n\nlangchain.set_key(api_key)\n\nresponse = langchain.ask("What is the capital of France?")\n\nprint(response.response)\n```\n\nThis will send the question "What is the capital of France?" to the LangChain API and print the response. You can customize the request by providing parameters like max_tokens, temperature, etc. The LangChain Python library documentation has more details on the available options. The key things are getting an API key and calling langchain.ask() with your question text. Let me know if you have any other questions!', additional_kwargs={}, example=False)

full_chain.invoke({"question": "whats 2 + 2"})

    AIMessage(content=' 4', additional_kwargs={}, example=False)