LangChain에서 강력한 체인 및 에이전트 구축

LangChain에서 강력한 체인 및 에이전트 구축

이 종합 가이드에서 우리는 강력한 체인과 에이전트 구축에 중점을 두고 LangChain의 세계에 대해 자세히 알아볼 것입니다. 체인의 기본을 이해하는 것부터 이를 대규모 언어 모델(LLM)과 결합하고 자율적인 의사 결정을 위한 정교한 에이전트를 소개하는 것까지 모든 것을 다룰 것입니다.

1. 체인 이해

1.1 LangChain의 체인이란 무엇입니까?

LangChain의 체인은 특정 순서로 데이터를 처리하는 일련의 작업 또는 작업입니다. 재사용 가능한 모듈식 워크플로를 허용하므로 복잡한 데이터 처리 및 언어 작업을 더 쉽게 처리할 수 있습니다. 체인은 정교한 AI 기반 시스템을 만들기 위한 구성 요소입니다.

1.2 체인의 종류

LangChain은 각각 다른 시나리오에 적합한 여러 유형의 체인을 제공합니다.

1. 순차 체인: 이 체인은 한 단계의 출력이 다음 단계의 입력으로 사용되는 선형 순서로 데이터를 처리합니다. 이는 간단한 단계별 프로세스에 이상적입니다.

2. 체인 매핑/감소: 이러한 체인에는 데이터 세트에 대한 함수를 매핑한 다음 결과를 단일 출력으로 줄이는 작업이 포함됩니다. 대규모 데이터 세트의 병렬 처리에 적합합니다.

3. 라우터 체인: 이 체인은 특정 조건에 따라 다양한 하위 체인에 입력을 전달하여 보다 복잡한 분기 작업 흐름을 허용합니다.

1.3 맞춤형 체인 생성

사용자 정의 체인을 생성하려면 체인의 일부가 될 특정 작업이나 기능을 정의해야 합니다. 다음은 사용자 정의 순차 체인의 예입니다.

from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

class CustomChain:
    def __init__(self, llm):
        self.llm = llm
        self.steps = []

    def add_step(self, prompt_template):
        prompt = PromptTemplate(template=prompt_template, input_variables=["input"])
        chain = LLMChain(llm=self.llm, prompt=prompt)
        self.steps.append(chain)

    def execute(self, input_text):
        for step in self.steps:
            input_text = step.run(input_text)
        return input_text

# Initialize the chain
llm = OpenAI(temperature=0.7)
chain = CustomChain(llm)

# Add steps to the chain
chain.add_step("Summarize the following text in one sentence: {input}")
chain.add_step("Translate the following English text to French: {input}")

# Execute the chain
result = chain.execute("LangChain is a powerful framework for building AI applications.")
print(result)

이 예에서는 먼저 입력 텍스트를 요약한 다음 이를 프랑스어로 번역하는 사용자 정의 체인을 생성합니다.

2. 체인과 LLM 결합

2.1 프롬프트 및 LLM과 체인 통합

체인은 프롬프트 및 LLM과 원활하게 통합되어 더욱 강력하고 유연한 시스템을 만들 수 있습니다. 예는 다음과 같습니다.

from langchain import PromptTemplate, LLMChain
from langchain.llms import OpenAI
from langchain.chains import SimpleSequentialChain

llm = OpenAI(temperature=0.7)

# First chain: Generate a topic
first_prompt = PromptTemplate(
    input_variables=["subject"],
    template="Generate a random {subject} topic:"
)
first_chain = LLMChain(llm=llm, prompt=first_prompt)

# Second chain: Write a paragraph about the topic
second_prompt = PromptTemplate(
    input_variables=["topic"],
    template="Write a short paragraph about {topic}:"
)
second_chain = LLMChain(llm=llm, prompt=second_prompt)

# Combine the chains
overall_chain = SimpleSequentialChain(chains=[first_chain, second_chain], verbose=True)

# Run the chain
result = overall_chain.run("science")
print(result)

이 예는 임의의 과학 주제를 생성한 후 이에 대한 단락을 작성하는 체인을 생성합니다.

2.2 Chain-LLM 상호작용 디버깅 및 최적화

체인-LLM 상호작용을 디버깅하고 최적화하려면 자세한 매개변수와 사용자 정의 콜백을 사용할 수 있습니다.

from langchain.callbacks import StdOutCallbackHandler
from langchain.chains import LLMChain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate

class CustomHandler(StdOutCallbackHandler):
    def on_llm_start(self, serialized, prompts, **kwargs):
        print(f"LLM started with prompt: {prompts[0]}")

    def on_llm_end(self, response, **kwargs):
        print(f"LLM finished with response: {response.generations[0][0].text}")

llm = OpenAI(temperature=0.7, callbacks=[CustomHandler()])
template = "Tell me a {adjective} joke about {subject}."
prompt = PromptTemplate(input_variables=["adjective", "subject"], template=template)
chain = LLMChain(llm=llm, prompt=prompt, verbose=True)

result = chain.run(adjective="funny", subject="programming")
print(result)

이 예에서는 사용자 정의 콜백 핸들러를 사용하여 LLM의 입력 및 출력에 대한 자세한 정보를 제공합니다.

3. 에이전트 소개

3.1 LangChain의 에이전트란 ​​무엇입니까?

LangChain의 에이전트는 작업을 수행하기 위해 도구를 사용하고 결정을 내릴 수 있는 자율적 개체입니다. LLM을 외부 도구와 결합하여 복잡한 문제를 해결함으로써 보다 역동적이고 적응력이 뛰어난 AI 시스템을 만들 수 있습니다.

3.2 내장 에이전트와 그 기능

LangChain은 zero-shot-react-description 에이전트와 같은 여러 내장 에이전트를 제공합니다.

from langchain.agents import load_tools, initialize_agent, AgentType
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)
tools = load_tools(["wikipedia", "llm-math"], llm=llm)

agent = initialize_agent(
    tools, 
    llm, 
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

result = agent.run("What is the square root of the year Plato was born?")
print(result)

이 예에서는 Wikipedia를 사용하고 수학적 계산을 수행하여 복잡한 질문에 답할 수 있는 에이전트를 만듭니다.

3.3 사용자 지정 에이전트 만들기

자신만의 도구와 에이전트 클래스를 정의하여 맞춤형 에이전트를 만들 수 있습니다. 이를 통해 특정 작업이나 도메인에 맞게 고도로 전문화된 에이전트를 구성할 수 있습니다.

다음은 맞춤 에이전트의 예입니다.

from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent
from langchain.prompts import StringPromptTemplate
from langchain import OpenAI, SerpAPIWrapper, LLMChain
from typing import List, Union
from langchain.schema import AgentAction, AgentFinish
import re

# Define custom tools
search = SerpAPIWrapper()
tools = [
    Tool(
        name="Search",
        func=search.run,
        description="Useful for answering questions about current events"
    )
]

# Define a custom prompt template
template = """Answer the following questions as best you can:

{input}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: {input}
Thought: To answer this question, I need to search for current information.
{agent_scratchpad}"""

class CustomPromptTemplate(StringPromptTemplate):
    template: str
    tools: List[Tool]

    def format(self, **kwargs) -> str:
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        kwargs["agent_scratchpad"] = thoughts
        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
        return self.template.format(**kwargs)

prompt = CustomPromptTemplate(
    template=template,
    tools=tools,
    input_variables=["input", "intermediate_steps"]
)

# Define a custom output parser
class CustomOutputParser:
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        if "Final Answer:" in llm_output:
            return AgentFinish(
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )

        action_match = re.search(r"Action: (\w+)", llm_output, re.DOTALL)
        action_input_match = re.search(r"Action Input: (.*)", llm_output, re.DOTALL)

        if not action_match or not action_input_match:
            raise ValueError(f"Could not parse LLM output: `{llm_output}`")

        action = action_match.group(1).strip()
        action_input = action_input_match.group(1).strip(" ").strip('"')

        return AgentAction(tool=action, tool_input=action_input, log=llm_output)

# Create the custom output parser
output_parser = CustomOutputParser()

# Define the LLM chain
llm = OpenAI(temperature=0)
llm_chain = LLMChain(llm=llm, prompt=prompt)

# Define the custom agent
agent = LLMSingleActionAgent(
    llm_chain=llm_chain,
    output_parser=output_parser,
    stop=["\nObservation:"],
    allowed_tools=[tool.name for tool in tools]
)

# Create an agent executor
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, , verbose=True)
# Run the agent
result = agent_executor.run(“What’s the latest news about AI?”)

print(result)

결론

LangChain의 체인과 에이전트는 정교한 AI 기반 시스템을 구축하기 위한 강력한 기능을 제공합니다. LLM(대형 언어 모델)과 통합하면 다양한 작업을 처리하도록 설계된 적응형 스마트 애플리케이션을 생성할 수 있습니다. LangChain 여정을 진행하면서 프레임워크의 잠재력을 완전히 활용하기 위해 다양한 체인 유형, 에이전트 설정 및 사용자 정의 모듈을 자유롭게 실험해 보세요.

위 내용은 LangChain에서 강력한 체인 및 에이전트 구축의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!