Tutorial Python do LangChain: Guia completo para iniciantes para começar
Este guia orienta você na configuração do LangChain, um framework Python para desenvolvimento de aplicações de IA, destacando seus principais componentes e funcionalidades.
LangChain é um Python framework que simplifica o processo de construção de aplicações de IA alimentadas por grandes modelos de linguagem (LLMs). Ele fornece ferramentas para gerenciar prompts, reter memória e integrar sistemas externos, permitindo que os desenvolvedores criem fluxos de trabalho complexos, como chatbots, analisadores de documentos e assistentes de pesquisa. Ao contrário das chamadas básicas de API, LangChain estrutura processos multietapas, facilitando a construção de soluções de IA escaláveis. Seja para automatizar o suporte ao cliente ou resumir documentos, LangChain ajuda a agilizar o desenvolvimento, economizando tempo e esforço.
Para quem é novo em IA, este tutorial oferece um guia passo a passo para configurar o LangChain, abrangendo tudo, desde a instalação de pacotes até a criação de fluxos de trabalho. Ao longo do caminho, ferramentas como Nó latente pode ajudar você a visualizar e prototipar esses fluxos de trabalho sem codificação pesada. Ao final, você estará preparado para criar aplicativos de IA prontos para produção, adaptados às suas necessidades.
LangChain Maestria em 2025 | Curso completo de 5 horas [LangChain v0.3]
Configurando seu LangChain Python Meio Ambiente
Um ambiente bem preparado economiza tempo na solução de problemas e permite que você se concentre na criação de aplicativos de IA.
Instalando LangChain e Pacotes Necessários
Para começar a usar o LangChain, certifique-se de ter o Python 3.8 ou posterior instalado. Você pode verificar sua versão do Python executando:
python --version
Se precisar de uma atualização, baixe a versão mais recente em python.org.
Em seguida, instale o LangChain usando pip:
pip install langchain
Isso instala a biblioteca principal, mas pacotes adicionais geralmente são necessários dependendo das necessidades do seu projeto. Por exemplo:
Para integrar com OpenAI modelos, instale o OpenAI pacote:
pip install langchain-openaiPara Abraçando o rosto modelos, use o pacote da comunidade:
pip install langchain-communityPara tarefas de processamento de documentos, como sistemas de perguntas e respostas ou análise de documentos, instale:
pip install langchain-text-splitters pypdf
É uma boa prática criar um ambiente virtual para o seu projeto a fim de evitar conflitos de dependência. Configure-o com:
python -m venv langchain_env
<span class="hljs-built_in">source</span> langchain_env/bin/activate <span class="hljs-comment"># On Windows: langchain_env\Scripts\activate</span>
Após a ativação, instale os pacotes necessários. Isso mantém as dependências do seu projeto isoladas e gerenciáveis.
Configurando chaves de API e variáveis de ambiente
Usar o LangChain de forma eficaz geralmente envolve conectar-se a serviços externos, como a API da OpenAI. Para isso, você precisará configurar chaves de API com segurança.
Comece gerando sua chave de API na plataforma OpenAI em plataforma.openai.com. Vá para a seção de chaves de API, crie uma nova chave e copie-a imediatamente, pois ela só será exibida uma vez.
Para armazenar suas chaves de API com segurança, use variáveis de ambiente. Veja como configurá-las:
Para Windows, use o prompt de comando:
setx OPENAI_API_KEY "your-api-key-here"Reinicie seu terminal para alterações permanentes. Para testes temporários, use:
<span class="hljs-built_in">set</span> OPENAI_API_KEY=your-api-key-herePara macOS e Linux, adicione a seguinte linha ao seu perfil de shell (por exemplo,
.bashrcor.zshrc):<span class="hljs-built_in">export</span> OPENAI_API_KEY=<span class="hljs-string">"your-api-key-here"</span>Aplique as alterações com
source ~/.bashrcou reinicie seu terminal.
Como alternativa, você pode usar um .env arquivo no diretório do seu projeto para gerenciar variáveis de ambiente. Isso mantém as credenciais em um só lugar:
OPENAI_API_KEY=your-api-key-here
ANTHROPIC_API_KEY=your-anthropic-key-here
HUGGINGFACE_API_TOKEN=your-hf-token-here
Instale o python-dotenv pacote para carregar essas variáveis em seus scripts:
pip install python-dotenv
Em seguida, inclua este trecho no início dos seus arquivos Python:
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
load_dotenv()
Este método garante que suas chaves de API permaneçam seguras e acessíveis em diferentes ambientes.
Dicas de configuração específicas da plataforma
Diferentes sistemas operacionais podem apresentar desafios específicos ao configurar o LangChain. Veja como lidar com eles:
WindowsProblemas relacionados ao caminho e interferência de antivírus são comuns. Se você encontrar erros de "comando não encontrado", certifique-se de que o diretório de scripts Python esteja no PATH do sistema. Para usuários que trabalham com WSL (Subsistema Windows para Linux), instale o LangChain no ambiente Linux para evitar problemas de compatibilidade.
MacOSUsuários com Apple Silicon (chips M1/M2) podem ter desempenho otimizado, mas podem precisar de versões específicas do pacote. Se as instalações do pip falharem, tente usar o conda:
conda install langchain -c conda-forgeAlgumas dependências também podem exigir ferramentas de linha de comando do Xcode, que você pode instalar com:
xcode-select --installLinux: A instalação geralmente é mais tranquila, mas os gerenciadores de pacotes variam. Para Ubuntu ou Debian, certifique-se de que os cabeçalhos de desenvolvimento do Python estejam instalados:
<span class="hljs-built_in">sudo</span> apt-get install python3-dev python3-pipNo CentOS ou RHEL, use:
<span class="hljs-built_in">sudo</span> yum install python3-devel python3-pip
Independentemente da sua plataforma, lembre-se de que trabalhar com grandes modelos de linguagem localmente requer bastante RAM. Embora 8 GB possam ser suficientes para modelos menores, 16 GB ou mais são recomendados para produção. Alternativamente, APIs baseadas em nuvem, como a da OpenAI, eliminam as restrições de memória local, tornando-as uma opção prática para muitos projetos.
Para quem está começando, ferramentas visuais como o Latenode podem simplificar o processo de aprendizado. O Latenode permite que você experimente os fluxos de trabalho do LangChain em uma interface amigável de arrastar e soltar. Essa abordagem é especialmente útil para iniciantes, oferecendo uma maneira prática de entender os conceitos antes de mergulhar no código.
Com seu ambiente pronto, você está pronto para explorar os principais componentes do LangChain e começar a criar soluções orientadas por IA.
Componentes principais do LangChain
LangChain é construído com elementos modulares que permitem aos desenvolvedores criar Fluxos de trabalho orientados por IA eficientemente. Ao compreender seus principais componentes, você pode desbloquear o potencial para criar aplicações de IA diversificadas e eficazes.
LLMs e modelos de bate-papo
O LangChain oferece suporte a dois tipos principais de modelos de linguagem: LLMs (Grandes Modelos de Linguagem) e Modelos de bate-papo. Cada um serve a um propósito único, influenciando a maneira como você cria prompts e gerencia respostas.
LLMs são projetados para tarefas de complementação de texto. São adequados para gerar texto, resumir informações ou criar conteúdo. Por exemplo:
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAI
llm = OpenAI(temperature=<span class="hljs-number">0.7</span>)
response = llm.invoke(<span class="hljs-string">"Write a brief explanation of machine learning:"</span>)
<span class="hljs-built_in">print</span>(response)
Modelos de bate-papo, por outro lado, são adaptados para conversas estruturadas. Eles desempenham funções como "sistema", "humano" e "assistente", tornando-os ideais para diálogos interativos:
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.schema <span class="hljs-keyword">import</span> HumanMessage, SystemMessage
chat = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
messages = [
SystemMessage(content=<span class="hljs-string">"You are a helpful AI assistant."</span>),
HumanMessage(content=<span class="hljs-string">"Explain the difference between Python lists and tuples."</span>)
]
response = chat.invoke(messages)
<span class="hljs-built_in">print</span>(response.content)
O temperatura O parâmetro desempenha um papel crucial na definição dos resultados. Valores mais baixos (por exemplo, 0.1–0.3) produzem respostas mais precisas e consistentes, enquanto valores mais altos (por exemplo, 0.7–1.0) estimulam a criatividade e a variabilidade.
A seguir, exploraremos como os modelos de prompt simplificam e padronizam as interações com esses modelos.
Modelos de prompt
Os modelos de prompt são uma maneira prática de criar prompts estruturados e reutilizáveis. Eles permitem definir um modelo uma única vez e inserir variáveis dinamicamente, economizando tempo e garantindo consistência.
Um basico Modelo de prompt funciona como uma string f do Python, mas oferece validação e formatação adicionais:
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
template = PromptTemplate(
input_variables=[<span class="hljs-string">"product"</span>, <span class="hljs-string">"audience"</span>],
template=<span class="hljs-string">"Write a marketing email for {product} targeting {audience}. Keep it under 200 words and include a clear call-to-action."</span>
)
prompt = template.<span class="hljs-built_in">format</span>(product=<span class="hljs-string">"AI writing software"</span>, audience=<span class="hljs-string">"small business owners"</span>)
Para conversas multifuncionais, Modelo de ChatPrompt fornece uma maneira estruturada de lidar com entradas dinâmicas:
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> ChatPromptTemplate
chat_template = ChatPromptTemplate.from_messages([
(<span class="hljs-string">"system"</span>, <span class="hljs-string">"You are an expert {domain} consultant with 10 years of experience."</span>),
(<span class="hljs-string">"human"</span>, <span class="hljs-string">"I need advice about {problem}. Please provide 3 specific recommendations."</span>)
])
formatted_prompt = chat_template.format_messages(
domain=<span class="hljs-string">"digital marketing"</span>,
problem=<span class="hljs-string">"improving email open rates"</span>
)
Solicitação de poucos disparos é outra técnica que inclui exemplos dentro do modelo para orientar a compreensão do modelo:
few_shot_template = PromptTemplate(
input_variables=[<span class="hljs-string">"input_text"</span>],
template=<span class="hljs-string">"""
Classify the sentiment of these examples:
Text: "I love this product!"
Sentiment: Positive
Text: "This is terrible quality."
Sentiment: Negative
Text: "It's okay, nothing special."
Sentiment: Neutral
Text: "{input_text}"
Sentiment:
"""</span>
)
Os modelos de prompt facilitam o gerenciamento de fluxos de trabalho complexos padronizando a maneira como as entradas são construídas.
Correntes
Cadeias são fluxos de trabalho que conectam múltiplos componentes para executar tarefas complexas. Cada etapa se baseia na saída da anterior, criando um processo contínuo.
O exemplo mais simples é um LLMChain, que combina um modelo de linguagem com um modelo de prompt:
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> LLMChain
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"Write a 3-paragraph blog post introduction about {topic}"</span>
)
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(topic=<span class="hljs-string">"sustainable energy solutions"</span>)
Para fluxos de trabalho mais complexos, Cadeias Sequenciais Permitir que várias etapas sejam vinculadas. Por exemplo, você pode gerar um esboço do blog, escrever uma introdução e, em seguida, criar uma conclusão:
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SimpleSequentialChain
<span class="hljs-comment"># First chain: Generate outline</span>
outline_chain = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"Create a detailed outline for a blog post about {topic}"</span>
)
)
<span class="hljs-comment"># Second chain: Write introduction based on outline</span>
intro_chain = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=[<span class="hljs-string">"outline"</span>],
template=<span class="hljs-string">"Based on this outline, write an engaging introduction:{outline}"</span>
)
)
<span class="hljs-comment"># Combine chains</span>
overall_chain = SimpleSequentialChain(
chains=[outline_chain, intro_chain],
verbose=<span class="hljs-literal">True</span>
)
final_result = overall_chain.run(<span class="hljs-string">"artificial intelligence in healthcare"</span>)
Correntes de roteador Adicionar recursos de tomada de decisão, direcionando entradas para subcadeias específicas com base no conteúdo. Isso é particularmente útil ao lidar com diversos tipos de entrada que exigem respostas personalizadas.
Para uma abordagem mais visual, ferramentas como o Latenode podem simplificar o processo de design e gerenciamento desses fluxos de trabalho. Ao visualizar a lógica da cadeia, você pode entender e refinar melhor suas soluções de IA.
Agentes e Ferramentas
Os agentes trazem flexibilidade aos seus fluxos de trabalho, tomando decisões e escolhendo ações dinamicamente. Ao contrário das cadeias, que seguem uma sequência fixa, os agentes adaptam seu comportamento com base na situação.
Ferramentas são funções que os agentes podem usar para interagir com sistemas externos. O LangChain fornece ferramentas integradas, mas você também pode criar ferramentas personalizadas.
Aqui está um exemplo de uma ferramenta integrada para a Pesquisa Google:
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> Tool
<span class="hljs-keyword">from</span> langchain.utilities <span class="hljs-keyword">import</span> GoogleSearchAPIWrapper
search = GoogleSearchAPIWrapper()
search_tool = Tool(
name=<span class="hljs-string">"Google Search"</span>,
description=<span class="hljs-string">"Search Google for current information"</span>,
func=search.run
)
E aqui está uma ferramenta personalizada para calcular alterações percentuais:
<span class="hljs-keyword">def</span> <span class="hljs-title function_">calculate_percentage</span>(<span class="hljs-params">input_string</span>):
<span class="hljs-string">"""Calculate percentage change between two numbers"""</span>
<span class="hljs-keyword">try</span>:
numbers = [<span class="hljs-built_in">float</span>(x.strip()) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> input_string.split(<span class="hljs-string">','</span>)]
<span class="hljs-keyword">if</span> <span class="hljs-built_in">len</span>(numbers) == <span class="hljs-number">2</span>:
change = ((numbers[<span class="hljs-number">1</span>] - numbers[<span class="hljs-number">0</span>]) / numbers[<span class="hljs-number">0</span>]) * <span class="hljs-number">100</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Percentage change: <span class="hljs-subst">{change:<span class="hljs-number">.2</span>f}</span>%"</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"Please provide exactly two numbers separated by a comma"</span>
<span class="hljs-keyword">except</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"Invalid input format"</span>
calc_tool = Tool(
name=<span class="hljs-string">"Percentage Calculator"</span>,
description=<span class="hljs-string">"Calculate percentage change between two numbers. Input: 'old_value, new_value'"</span>,
func=calculate_percentage
)
Agentes ReAct (Raciocínio e Ação) combinam a tomada de decisão com o uso de ferramentas. Eles analisam a situação, decidem sobre uma ação, usam ferramentas e avaliam o resultado:
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> create_react_agent, AgentExecutor
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
llm = ChatOpenAI(temperature=<span class="hljs-number">0</span>)
tools = [search_tool, calc_tool]
<span class="hljs-comment"># Create agent</span>
agent = create_react_agent(
llm=llm,
tools=tools,
prompt=PromptTemplate.from_template(<span class="hljs-string">"""
You are a helpful assistant. Use the available tools to answer questions accurately.
Available tools: {tool_names}
Tool descriptions: {tools}
Question: {input}
Thought: {agent_scratchpad}
"""</span>)
)
<span class="hljs-comment"># Execute agent</span>
agent_executor = AgentExecutor(agent=agent)
Agentes e ferramentas fornecem a adaptabilidade necessária para aplicações dinâmicas do mundo real, tornando o LangChain uma estrutura versátil para desenvolvimento de IA.
sbb-itb-23997f1
Construindo seu primeiro aplicativo LangChain
Aprenda a criar um aplicativo LangChain do zero para aprofundar seu conhecimento sobre seus recursos.
Chamada básica de LLM
Uma chamada básica ao Large Language Model (LLM) é o ponto de partida para a construção de fluxos de trabalho mais avançados do LangChain. Abaixo, um exemplo de um aplicativo simples de geração de texto:
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAI
<span class="hljs-keyword">import</span> os
<span class="hljs-comment"># Set your API key</span>
os.environ[<span class="hljs-string">"OPENAI_API_KEY"</span>] = <span class="hljs-string">"your-api-key-here"</span>
<span class="hljs-comment"># Initialize the LLM (temperature determines creativity: 0.1-0.3 for factual, 0.7-0.9 for creative)</span>
llm = OpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Generate a response</span>
response = llm.invoke(<span class="hljs-string">"Write a professional email subject line for a product launch announcement"</span>)
<span class="hljs-built_in">print</span>(response)
Para um aplicativo de resposta a perguntas, você pode estruturar a interação com uma função:
<span class="hljs-keyword">def</span> <span class="hljs-title function_">ask_question</span>(<span class="hljs-params">question</span>):
prompt = <span class="hljs-string">f"""
Answer the following question clearly and concisely:
Question: <span class="hljs-subst">{question}</span>
Answer:
"""</span>
<span class="hljs-keyword">return</span> llm.invoke(prompt)
<span class="hljs-comment"># Test the function</span>
result = ask_question(<span class="hljs-string">"What are the benefits of using renewable energy?"</span>)
<span class="hljs-built_in">print</span>(result)
Essa abordagem direta cria uma aplicação de IA funcional. Embora simples, ela serve como base para fluxos de trabalho mais avançados, que você pode expandir usando cadeias de várias etapas.
Construindo uma cadeia de várias etapas
Cadeias de várias etapas permitem o processamento sequencial de informações, onde cada etapa se baseia na anterior. Aqui está um exemplo de um gerador de posts de blog que descreve tópicos, escreve uma introdução e adiciona uma chamada para ação:
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SimpleSequentialChain
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-comment"># Initialize the model</span>
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Step 1: Create an outline</span>
outline_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"""
Create a detailed 5-point outline for a blog post about {topic}.
Include main points and 2-3 sub-points for each section.
Format as a numbered list.
"""</span>
)
outline_chain = outline_prompt | llm
<span class="hljs-comment"># Step 2: Write the introduction</span>
intro_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"outline"</span>],
template=<span class="hljs-string">"""
Based on this outline, write an engaging 200-word introduction:
{outline}
Make it compelling and include a hook to grab readers' attention.
"""</span>
)
intro_chain = intro_prompt | llm
<span class="hljs-comment"># Step 3: Add a call-to-action</span>
cta_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"introduction"</span>],
template=<span class="hljs-string">"""
Based on this introduction, suggest 3 relevant call-to-action options:
{introduction}
Format as: 1. [Action] - [Brief description]
"""</span>
)
cta_chain = cta_prompt | llm
<span class="hljs-comment"># Combine all steps</span>
blog_chain = SimpleSequentialChain(
chains=[outline_chain, intro_chain, cta_chain],
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Execute the chain</span>
final_result = blog_chain.invoke({<span class="hljs-string">"input"</span>: <span class="hljs-string">"sustainable web development practices"</span>})
<span class="hljs-built_in">print</span>(final_result)
Você também pode criar fluxos de trabalho que combinam várias entradas e saídas em diferentes estágios:
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SequentialChain
<span class="hljs-comment"># Research and analysis chain</span>
research_chain = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>, <span class="hljs-string">"audience"</span>],
template=<span class="hljs-string">"Research key points about {topic} for {audience}. List 5 main insights."</span>
) | llm
analysis_chain = PromptTemplate(
input_variables=[<span class="hljs-string">"research"</span>, <span class="hljs-string">"business_goal"</span>],
template=<span class="hljs-string">"""
Analyze this research: {research}
Create actionable recommendations for: {business_goal}
Provide 3 specific strategies with expected outcomes.
"""</span>
) | llm
<span class="hljs-comment"># Combine chains</span>
combined_chain = SequentialChain(
chains=[research_chain, analysis_chain],
input_variables=[<span class="hljs-string">"topic"</span>, <span class="hljs-string">"audience"</span>, <span class="hljs-string">"business_goal"</span>],
output_variables=[<span class="hljs-string">"final_analysis"</span>]
)
Essas cadeias de múltiplas etapas elevam chamadas simples de IA a fluxos de trabalho capazes de lidar com tarefas complexas, gerando resultados estruturados e profissionais. Uma vez implementadas essas cadeias, você pode aprimorar ainda mais seu aplicativo com recursos como memória e agentes.
Adicionando Memória e Agentes
Memória e agentes trazem consciência de contexto e tomada de decisão dinâmica para aplicativos LangChain.
ConversationBufferMemory mantém o controle de toda a conversa, tornando-o ideal para chatbots ou sistemas interativos:
<span class="hljs-keyword">from</span> langchain.memory <span class="hljs-keyword">import</span> ConversationBufferMemory
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> ConversationChain
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-comment"># Set up memory and model</span>
memory = ConversationBufferMemory()
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Create a conversation chain with memory</span>
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Test the conversation</span>
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"Hi, I'm working on a Python project about data analysis."</span>))
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"What libraries would you recommend?"</span>))
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"Can you explain pandas in more detail?"</span>))
<span class="hljs-comment"># View conversation history</span>
<span class="hljs-built_in">print</span>(<span class="hljs-string">"Conversation History:"</span>)
<span class="hljs-built_in">print</span>(memory.buffer)
Para aplicações que exigem gerenciamento de memória eficiente, ConversaResumoMemória condensa interações mais antigas:
<span class="hljs-keyword">from</span> langchain.memory <span class="hljs-keyword">import</span> ConversationSummaryMemory
summary_memory = ConversationSummaryMemory(
llm=llm,
max_token_limit=<span class="hljs-number">1000</span>
)
<span class="hljs-comment"># Automatically summarizes older conversations</span>
conversation_with_summary = ConversationChain(
llm=llm,
memory=summary_memory
)
Agentes com ferramentas habilitar aplicativos dinâmicos que interagem com sistemas externos e executam tarefas em tempo real:
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> create_react_agent, AgentExecutor
<span class="hljs-keyword">from</span> langchain.tools <span class="hljs-keyword">import</span> Tool
<span class="hljs-comment"># Custom tool for weather data</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">get_weather</span>(<span class="hljs-params">city</span>):
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Current weather in <span class="hljs-subst">{city}</span>: 72°F, partly cloudy"</span>
weather_tool = Tool(
name=<span class="hljs-string">"Weather"</span>,
description=<span class="hljs-string">"Get current weather for any city"</span>,
func=get_weather
)
<span class="hljs-comment"># Custom tool for calculations</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">calculate</span>(<span class="hljs-params">expression</span>):
<span class="hljs-keyword">try</span>:
result = <span class="hljs-built_in">eval</span>(expression.replace(<span class="hljs-string">"^"</span>, <span class="hljs-string">"**"</span>))
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Result: <span class="hljs-subst">{result}</span>"</span>
<span class="hljs-keyword">except</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"Invalid mathematical expression"</span>
calc_tool = Tool(
name=<span class="hljs-string">"Calculator"</span>,
description=<span class="hljs-string">"Perform mathematical calculations"</span>,
func=calculate
)
<span class="hljs-comment"># Create an agent with tools and memory</span>
tools = [weather_tool, calc_tool]
agent_memory = ConversationBufferMemory(memory_key=<span class="hljs-string">"chat_history"</span>)
agent = create_react_agent(
llm=llm,
tools=tools,
prompt=<span class="hljs-string">"""You are a helpful assistant with access to tools.
Available tools: {tool_names}
Tool descriptions: {tools}
Use tools when needed to provide accurate information.
Previous conversation: {chat_history}
Human: {input}
{agent_scratchpad}"""</span>
)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=agent_memory,
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Test the agent</span>
result = agent_executor.invoke({<span class="hljs-string">"input"</span>: <span class="hljs-string">"What's the weather in San Francisco and what's 15 * 24?"</span>})
<span class="hljs-built_in">print</span>(result)
Embora o LangChain Python ofereça uma estrutura de programação robusta, muitos desenvolvedores consideram a interface visual do Latenode um excelente complemento. Usando o Latenode, você pode prototipar fluxos de trabalho como Solicitação HTTP → OpenAI GPT-4 → Armazenamento de Memória → Formatação de Resposta sem se aprofundar no código, reforçando sua compreensão desses conceitos enquanto cria aplicativos funcionais.
Essa combinação de memória e agentes permite aplicativos que retêm contexto, tomam decisões informadas e interagem perfeitamente com sistemas externos.
Aprendendo LangChain com Nó latente Fluxos de trabalho visuais
Fluxos de trabalho visuais oferecem uma maneira única de projetar e compreender o comportamento dos agentes, apresentando-os em um formato gráfico. Essa abordagem permite incluir ramificações e loops condicionais com facilidade. Enquanto o framework Python da LangChain é inegavelmente robusto, o construtor de fluxos de trabalho visuais da Latenode oferece uma maneira prática e intuitiva de compreender conceitos de IA e criar aplicações funcionais. Ele simplifica ideias complexas e as torna mais acessíveis, especialmente para quem não conhece os fluxos de trabalho de IA.
Construtor de fluxo de trabalho visual para LangChain
A interface de arrastar e soltar do Latenode transforma os conceitos abstratos do LangChain em fluxos de trabalho claros e visuais. Em vez de se preocupar com a sintaxe do Python, você pode se concentrar em como os dados se movem entre os componentes.
Neste sistema, os elementos LangChain são representados como nós interconectados. Por exemplo, um Solicitação HTTP nó pode desencadear um OpenAI GPT-4 nó. A saída poderia então fluir para um Armazenamento de memória nó e finalmente passar por um Formatação de Resposta nó para apresentação. Esta configuração espelha o que você normalmente codificaria em Python, mas remove as barreiras de sintaxe, tornando-a especialmente útil para iniciantes.
A representação visual da plataforma dá vida aos conceitos do LangChain, permitindo que os alunos vejam como os fluxos de trabalho de IA funcionam. Integrações e modelos de IA compatíveis oferecem a liberdade de experimentar ferramentas que você eventualmente usaria em aplicações do mundo real. Por exemplo, ao explorar o LangChain ConversationBufferMemory, você pode rastrear visualmente como o histórico de conversas flui de uma interação para a próxima. Essa clareza prática torna as ideias abstratas mais tangíveis e acelera o aprendizado em comparação com os métodos de codificação tradicionais, nos quais a depuração de problemas de memória geralmente exige um registro extenso.
Criando protótipos visuais do LangChain
O Latenode permite que você crie protótipos funcionais desde o início. Por exemplo, você pode replicar um gerador de posts de blog multietapas como um fluxo de trabalho visual: Webhook HTTP → OpenAI GPT-4 (Esboço) → OpenAI GPT-4 (Introdução) → OpenAI GPT-4 (Chamada para Ação) → planilhas do Google para armazenamento.
Essa abordagem visual simplifica a lógica por trás dos fluxos de trabalho. Fluxos condicionais e transformações de dados são representados por nós individuais, facilitando a compreensão de cada etapa. Por exemplo, ao criar um agente meteorológico, você pode conectar um API meteorológica nó para um OpenAI GPT-4 nó e então usar nós lógicos para ramificar a saída com base em condições específicas.
Latenode também inclui um Copiloto de código de IA, que gera snippets JavaScript alinhados aos padrões Python do LangChain. Esse recurso preenche a lacuna entre fluxos de trabalho visuais e a codificação, ajudando os alunos a enxergar os aspectos conceituais e técnicos de seus projetos. Muitos usuários consideram essa abordagem dupla útil para entender fluxos de trabalho antes de implementá-los em Python. A depuração também é simplificada, pois o formato visual permite monitorar o status do agente e o processo de tomada de decisão em cada etapa.
Benefícios do Latenode para iniciantes
O Latenode oferece diversas vantagens para quem está começando a usar o LangChain. Um dos principais benefícios é a capacidade de iterar rapidamente. O desenvolvimento tradicional em Python geralmente envolve a configuração de ambientes, o gerenciamento de dependências e a solução de problemas de sintaxe antes mesmo de você poder testar seus fluxos de trabalho. O Latenode remove esses obstáculos, permitindo que você mergulhe diretamente na compreensão da arquitetura do LangChain.
A plataforma também é econômica para experimentação. Seu modelo de precificação baseado em execução cobra apenas pelo tempo de execução real, não por chamada de API, tornando-a ideal para testes durante a fase de aprendizado. Free plan, que inclui 300 créditos de execução por mês, oferece amplo espaço para experimentação e prototipagem.
Além de aprender os conceitos do LangChain, o Latenode apresenta integrações do mundo real. Você pode trabalhar com ferramentas como Noção, planilhas do Google, Stripe e WhatsApp, adquirindo experiência prática com aplicativos prontos para produção. Esta exposição prática prepara você para criar soluções prontas para os negócios.
O Latenode também estende os recursos do LangChain para automação web por meio de seu recurso de navegador headless. Você pode criar fluxos de trabalho que coletam dados, preenchem formulários e interagem com aplicações web, aplicando os padrões de memória e agente do LangChain. Esta aplicação prática preenche a lacuna entre conceitos teóricos e casos de uso práticos.
Por fim, o formato visual do Latenode incentiva a colaboração. As equipes podem revisar, modificar e compreender fluxos de trabalho facilmente, sem a necessidade de amplo conhecimento de Python. Isso o torna uma ótima ferramenta tanto para ambientes educacionais quanto para equipes de desenvolvimento, promovendo o aprendizado compartilhado e um progresso mais rápido.
Próximos passos: da aprendizagem à produção
A proficiência em LangChain Python abre as portas para a criação de aplicações avançadas de IA. No entanto, passar do aprendizado para a produção exige um planejamento cuidadoso e as ferramentas certas para garantir o sucesso.
Recursos para Aprendizagem Avançada
O Documentação LangChain é um recurso essencial para um mergulho mais profundo em tópicos avançados. Ele fornece guias detalhados sobre composição de cadeias complexas e recursos de streaming. Além disso, o Lang Smith documentação de integração é inestimável para depuração e monitoramento de aplicativos em ambientes de produção.
Para obter informações práticas, Repositórios do GitHub oferecem exemplos do mundo real que vão além dos tutoriais básicos. O oficial Modelos LangChain O repositório é particularmente útil, fornecendo projetos iniciais prontos para produção para tarefas como sistemas de perguntas e respostas de documentos, agentes SQL e aplicações multimodais. Esses modelos enfatizam aspectos críticos como tratamento de erros, registro em log e gerenciamento de configuração, que muitas vezes são negligenciados em recursos para iniciantes.
Envolvendo-se com recursos da comunidade Comunidades como o servidor LangChain no Discord e o Reddit também podem ser úteis. Desenvolvedores frequentemente compartilham suas experiências com desafios de produção, oferecendo dicas sobre otimização de desempenho e gerenciamento de custos para aplicativos com uso intensivo de API.
Para aqueles que buscam aprofundar seus conhecimentos, o Livro de receitas LangChain É uma leitura obrigatória. Inclui técnicas avançadas para gerenciamento de memória, integração de ferramentas e orquestração de agentes. Seções sobre ferramentas personalizadas e sistemas multiagentes são particularmente úteis para a construção de soluções de negócios complexas e escaláveis.
Esses recursos fornecem a base de conhecimento necessária para a transição dos seus projetos LangChain do desenvolvimento para a produção.
Migrando para soluções prontas para produção
Levar seu aplicativo para produção envolve abordar vários aspectos críticos, incluindo tratamento de erros, escalabilidade e monitoramento.
Limitação de taxa torna-se essencial ao trabalhar com APIs como OpenAI ou AntrópicoExceder as cotas pode levar a interrupções no serviço, impactando a experiência do usuário.
Gestão do meio ambiente também assume maior importância. Além do simples armazenamento de chaves de API, as configurações de produção se beneficiam de configurações estruturadas, adaptadas para ambientes de desenvolvimento, preparação e produção. Ferramentas seguras de gerenciamento de credenciais, como Gerenciador de segredos da AWS or Azure Key Vault, pode ajudar a proteger informações confidenciais.
Registro e observabilidade são essenciais para entender o desempenho do aplicativo e as interações do usuário. Embora o LangSmith ofereça rastreamento integrado para aplicativos LangChain, muitas equipes também implementam registros personalizados para rastrear métricas específicas do negócio.
À medida que o uso aumenta, otimização de custos torna-se uma prioridade. Técnicas como cache, refinamento rápido e escolha dos modelos certos podem ajudar a reduzir despesas sem comprometer a funcionalidade.
Testar aplicações de IA exige uma abordagem diferente em comparação com softwares tradicionais. Estruturas de avaliação devem mensurar aspectos como qualidade da resposta, precisão factual e consistência. Algumas equipes também utilizam conjuntos de dados valiosos para realizar testes de regressão, garantindo que suas aplicações permaneçam confiáveis à medida que evoluem.
Para equipes que buscam simplificar esses desafios de produção, o Latenode oferece uma solução poderosa para automatizar e gerenciar fluxos de trabalho com eficiência.
Usando Latenode para automação de negócios
O Latenode preenche a lacuna entre protótipos e soluções prontas para produção, eliminando grande parte da complexidade da infraestrutura.
Está banco de dados embutido permite que desenvolvedores armazenem históricos de conversas, preferências do usuário e estados de aplicativos diretamente nos fluxos de trabalho. Isso elimina a necessidade de armazenamento externo de dados, otimizando a arquitetura e acelerando a implantação.
O automação de navegador sem cabeça O recurso estende os recursos do LangChain para fluxos de trabalho baseados na web. Isso permite que as empresas criem agentes de IA que interagem com aplicativos da web — preenchendo formulários, extraindo dados e mantendo o contexto conversacional com os sistemas de memória do LangChain.
Com mais 300 integrações de aplicativosO Latenode facilita a automatização de processos empresariais complexos. Por exemplo, um fluxo de trabalho de produção pode integrar Salesforce, OpenAI GPT-4, Slacke Planilhas Google para automatizar tarefas como qualificação de leads e acompanhamentos. Esses fluxos de trabalho, que normalmente exigiriam um extenso desenvolvimento personalizado em Python, podem ser criados rapidamente usando a plataforma da Latenode.
Para empresas que estão crescendo além da experimentação, a Latenode Plano de empresa começa em US$ 299/mês, oferecendo créditos de execução ilimitados e um histórico de log de 60 dias. Organizações que lidam com dados confidenciais também podem optar por opção de auto-hospedagem, garantindo a conformidade com os requisitos internos e regulatórios.
Muitas equipes adotam uma abordagem híbrida, usando o Latenode como base para a automação da produção, enquanto mantêm aplicações Python LangChain personalizadas para lógica especializada de IA. Essa estratégia combina a confiabilidade e os recursos de integração do Latenode com a flexibilidade do desenvolvimento sob medida, oferecendo soluções robustas e escaláveis.
Perguntas
O que torna o LangChain uma escolha melhor do que chamadas de API tradicionais para desenvolvimento de IA?
O LangChain se destaca como uma ferramenta valiosa para a construção de aplicações de IA em comparação com as chamadas de API tradicionais. Ele suporta fluxos de trabalho estruturados Oferecendo recursos como gerenciamento de memória, raciocínio em várias etapas e integração perfeita de ferramentas. Esses recursos permitem que os desenvolvedores projetem sistemas de IA avançados e escaláveis.
Ao otimizar a orquestração de fluxos de trabalho complexos, o LangChain ajuda a reduzir o tempo de desenvolvimento, incentivando a modularidade e a reutilização de componentes. Isso o torna uma excelente estrutura para a criação de aplicações modernas de IA, especialmente aquelas que exigem tomada de decisão inteligente ou interações dinâmicas do usuário.
Como o LangChain lida com os desafios de configuração em diferentes sistemas operacionais?
Configurar o LangChain pode ser complicado, pois depende do seu sistema operacional e hardware. Os desafios comuns incluem gerenciar dependências, resolver problemas de compatibilidade de pacotes e garantir suporte para requisitos específicos de hardware, como GPUs para tarefas avançadas.
Para facilitar o processo, existem guias passo a passo projetados para sistemas específicos, como macOS ou Windows. Esses guias abordam problemas comuns de configuração e fornecem instruções claras, mesmo para dispositivos mais novos, como o MacBook Pro M2. Usando esses recursos, você pode agilizar o processo de instalação e começar a trabalhar com o LangChain com o mínimo de complicações.
Iniciantes podem usar o construtor de fluxo de trabalho visual do Latenode para criar aplicativos LangChain sem habilidades avançadas de codificação?
Os iniciantes encontrarão o Latenode's construtor de fluxo de trabalho visual uma ferramenta acessível para criar e prototipar aplicações LangChain, mesmo sem conhecimentos avançados de codificação. A plataforma interface de arrastar e soltar simplifica o processo de criação de fluxos de trabalho de IA, permitindo que os usuários priorizem a compreensão de conceitos em vez de lidar com programação complexa.
Por meio de sua abordagem de mapeamento visual, o Latenode ajuda novos usuários a compreender e implementar rapidamente os recursos do LangChain, como cadeias, agentes e memória. Esse método prático acelera o aprendizado e oferece resultados imediatos, tornando-se um excelente ponto de partida para iniciantes no desenvolvimento de IA.
Artigos Relacionados
