Partie Construire des chaînes et des agents puissants dans LangChain

Construire des chaînes et des agents puissants dans LangChain

Dans ce guide complet, nous plongerons profondément dans le monde de LangChain, en nous concentrant sur la construction de chaînes et d'agents puissants. Nous couvrirons tout, de la compréhension des principes fondamentaux des chaînes à leur combinaison avec de grands modèles de langage (LLM) et à l'introduction d'agents sophistiqués pour une prise de décision autonome.

1. Comprendre les chaînes

1.1 Que sont les chaînes dans LangChain ?

Les chaînes dans LangChain sont des séquences d'opérations ou de tâches qui traitent les données dans un ordre spécifique. Ils permettent des flux de travail modulaires et réutilisables, facilitant la gestion de tâches complexes de traitement de données et de langage. Les chaînes sont les éléments constitutifs de la création de systèmes sophistiqués basés sur l'IA.

1.2 Types de chaînes

LangChain propose plusieurs types de chaînes, chacune adaptée à différents scénarios :

1. Chaînes séquentielles : ces chaînes traitent les données dans un ordre linéaire, où la sortie d'une étape sert d'entrée pour la suivante. Ils sont idéaux pour des processus simples et étape par étape.

2. Mapper/Réduire les chaînes : Ces chaînes impliquent de mapper une fonction sur un ensemble de données, puis de réduire les résultats à une seule sortie. Ils sont parfaits pour le traitement parallèle de grands ensembles de données.

3. Chaînes de routeurs : ces chaînes dirigent les entrées vers différentes sous-chaînes en fonction de certaines conditions, permettant des flux de travail de branchement plus complexes.

1.3 Création de chaînes personnalisées

Créer des chaînes personnalisées implique de définir des opérations ou des fonctions spécifiques qui feront partie de la chaîne. Voici un exemple de chaîne séquentielle personnalisée :

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)

Cet exemple crée une chaîne personnalisée qui résume d'abord un texte saisi, puis le traduit en français.

2. Combiner chaînes et LLM

2.1 Intégration de chaînes avec des invites et des LLM

Les chaînes peuvent être intégrées de manière transparente aux invites et aux LLM pour créer des systèmes plus puissants et plus flexibles. Voici un exemple :

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)

Cet exemple crée une chaîne qui génère un sujet scientifique aléatoire, puis écrit un paragraphe à ce sujet.

2.2 Débogage et optimisation des interactions chaîne-LLM

Pour déboguer et optimiser les interactions chaîne-LLM, vous pouvez utiliser le paramètre verbeux et les rappels personnalisés :

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)

Cet exemple utilise un gestionnaire de rappel personnalisé pour fournir des informations détaillées sur l'entrée et la sortie du LLM.

3. Présentation des agents

3.1 Que sont les agents dans LangChain ?

Les agents de LangChain sont des entités autonomes qui peuvent utiliser des outils et prendre des décisions pour accomplir des tâches. Ils combinent des LLM avec des outils externes pour résoudre des problèmes complexes, permettant ainsi des systèmes d'IA plus dynamiques et adaptables.

3.2 Agents intégrés et leurs capacités

LangChain fournit plusieurs agents intégrés, tels que l'agent 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)

Cet exemple crée un agent capable d'utiliser Wikipédia et d'effectuer des calculs mathématiques pour répondre à des questions complexes.

3.3 Création d'agents personnalisés

Vous pouvez créer des agents personnalisés en définissant vos propres outils et classes d'agents. Cela permet d'avoir des agents hautement spécialisés adaptés à des tâches ou des domaines spécifiques.

Voici un exemple d'agent personnalisé :

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)

Conclusion

Les chaînes et agents de LangChain offrent des capacités robustes pour construire des systèmes sophistiqués basés sur l'IA. Lorsqu'ils sont intégrés à de grands modèles de langage (LLM), ils permettent la création d'applications adaptables et intelligentes conçues pour s'attaquer à une variété de tâches. Au fur et à mesure que vous progressez dans votre parcours LangChain, n'hésitez pas à expérimenter divers types de chaînes, configurations d'agents et modules personnalisés pour exploiter pleinement le potentiel du framework.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!