LangChain Python-Tutorial: Vollständiger Leitfaden für Anfänger zum Einstieg
Dieser Leitfaden führt Sie durch die Einrichtung von LangChain, einem Python-Framework zum Erstellen von KI-Anwendungen, und hebt dessen Kernkomponenten und Funktionen hervor.
LangChain ist eine Python Framework, das die Erstellung von KI-Anwendungen auf Basis großer Sprachmodelle (LLMs) vereinfacht. Es bietet Tools zur Verwaltung von Eingabeaufforderungen, zur Speicherung von Speicher und zur Integration externer Systeme. So können Entwickler komplexe Workflows wie Chatbots, Dokumentenanalysatoren und Forschungsassistenten erstellen. Im Gegensatz zu einfachen API-Aufrufen LangChain strukturiert mehrstufige Prozesse und erleichtert so die Entwicklung skalierbarer KI-Lösungen. Ob Sie den Kundensupport automatisieren oder Dokumente zusammenfassen, LangChain hilft, die Entwicklung zu rationalisieren und spart Zeit und Aufwand.
Für KI-Neulinge bietet dieses Tutorial eine Schritt-für-Schritt-Anleitung zur Einrichtung von LangChain, die alles von der Installation von Paketen bis zum Erstellen von Workflows abdeckt. Dabei werden Tools wie Latenknoten Mit diesem Tool können Sie diese Workflows ohne aufwändige Programmierung visualisieren und Prototypen erstellen. Am Ende sind Sie in der Lage, produktionsreife KI-Anwendungen zu erstellen, die auf Ihre Bedürfnisse zugeschnitten sind.
LangChain Meisterschaft im Jahr 2025 | Vollständiger 5-Stunden-Kurs [LangChain v0.3]
Einrichten Ihrer LangChain Python Arbeitsumfeld
Eine gut vorbereitete Umgebung spart Zeit bei der Fehlerbehebung und ermöglicht es Ihnen, sich auf die Erstellung von KI-Anwendungen zu konzentrieren.
Installieren von LangChain und erforderlichen Paketen
Um mit LangChain zu beginnen, stellen Sie sicher, dass Sie Python 3.8 oder höher installiert haben. Sie können Ihre Python-Version überprüfen, indem Sie Folgendes ausführen:
python --version
Wenn Sie ein Update benötigen, laden Sie die neueste Version herunter von python.org.
Installieren Sie als Nächstes LangChain mit pip:
pip install langchain
Dadurch wird die Kernbibliothek installiert. Je nach Projektanforderungen sind jedoch häufig zusätzliche Pakete erforderlich. Beispiel:
Zur Integration mit OpenAI Modelle, installieren Sie die OpenAI Paket:
pip install langchain-openaiFür Gesicht umarmen Modelle, verwenden Sie das Community-Paket:
pip install langchain-communityInstallieren Sie für Dokumentverarbeitungsaufgaben wie Q&A-Systeme oder Dokumentanalyse:
pip install langchain-text-splitters pypdf
Um Abhängigkeitskonflikte zu vermeiden, empfiehlt es sich, eine virtuelle Umgebung für Ihr Projekt zu erstellen. Richten Sie diese mit folgenden Methoden ein:
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>
Installieren Sie nach der Aktivierung die erforderlichen Pakete. Dadurch bleiben Ihre Projektabhängigkeiten isoliert und verwaltbar.
Konfigurieren von API-Schlüsseln und Umgebungsvariablen
Um LangChain effektiv nutzen zu können, ist häufig die Verbindung zu externen Diensten wie der OpenAI-API erforderlich. Dazu müssen Sie API-Schlüssel sicher einrichten.
Beginnen Sie mit der Generierung Ihres API-Schlüssels auf der OpenAI-Plattform unter Plattform.openai.com. Gehen Sie zum Abschnitt API-Schlüssel, erstellen Sie einen neuen Schlüssel und kopieren Sie ihn sofort, da er nur einmal angezeigt wird.
Verwenden Sie Umgebungsvariablen, um Ihre API-Schlüssel sicher zu speichern. So richten Sie sie ein:
Für Windows, verwenden Sie die Eingabeaufforderung:
setx OPENAI_API_KEY "your-api-key-here"Starten Sie Ihr Terminal neu, um dauerhafte Änderungen vorzunehmen. Verwenden Sie für temporäre Tests:
<span class="hljs-built_in">set</span> OPENAI_API_KEY=your-api-key-hereFür macOS und Linux, fügen Sie Ihrem Shell-Profil die folgende Zeile hinzu (z. B.
.bashrcor.zshrc):<span class="hljs-built_in">export</span> OPENAI_API_KEY=<span class="hljs-string">"your-api-key-here"</span>Übernehmen Sie die Änderungen mit
source ~/.bashrcoder starten Sie Ihr Terminal neu.
Alternativ können Sie a verwenden .env Datei in Ihrem Projektverzeichnis, um Umgebungsvariablen zu verwalten. Dadurch werden die Anmeldeinformationen an einem Ort gespeichert:
OPENAI_API_KEY=your-api-key-here
ANTHROPIC_API_KEY=your-anthropic-key-here
HUGGINGFACE_API_TOKEN=your-hf-token-here
Installieren Sie das python-dotenv Paket, um diese Variablen in Ihre Skripte zu laden:
pip install python-dotenv
Fügen Sie dann diesen Codeausschnitt am Anfang Ihrer Python-Dateien ein:
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
load_dotenv()
Diese Methode stellt sicher, dass Ihre API-Schlüssel sicher bleiben und in verschiedenen Umgebungen zugänglich sind.
Plattformspezifische Einrichtungstipps
Verschiedene Betriebssysteme können bei der Einrichtung von LangChain besondere Herausforderungen mit sich bringen. So können Sie diese bewältigen:
Windows: Pfadbezogene Probleme und Virenschutzstörungen sind häufig. Wenn die Fehlermeldung „Befehl nicht gefunden“ auftritt, stellen Sie sicher, dass sich Ihr Python-Skriptverzeichnis im Systempfad befindet. Benutzer, die mit WSL (Windows Subsystem für Linux) arbeiten, installieren LangChain innerhalb der Linux-Umgebung, um Kompatibilitätsprobleme zu vermeiden.
macOS: Benutzer mit Apple Silicon (M1/M2-Chips) erzielen möglicherweise eine optimierte Leistung, benötigen aber möglicherweise spezielle Paketversionen. Wenn die Pip-Installation fehlschlägt, versuchen Sie es mit Conda:
conda install langchain -c conda-forgeFür einige Abhängigkeiten sind möglicherweise auch Xcode-Befehlszeilentools erforderlich, die Sie mit folgendem Befehl installieren können:
xcode-select --installLinux: Die Installation verläuft im Allgemeinen reibungsloser, die Paketmanager variieren jedoch. Stellen Sie bei Ubuntu oder Debian sicher, dass die Python-Entwicklungsheader installiert sind:
<span class="hljs-built_in">sudo</span> apt-get install python3-dev python3-pipVerwenden Sie unter CentOS oder RHEL:
<span class="hljs-built_in">sudo</span> yum install python3-devel python3-pip
Unabhängig von Ihrer Plattform sollten Sie bedenken, dass die lokale Arbeit mit großen Sprachmodellen viel RAM erfordert. Während 8 GB für kleinere Modelle ausreichen können, werden für die Produktion 16 GB oder mehr empfohlen. Alternativ beseitigen Cloud-basierte APIs wie die von OpenAI lokale Speicherbeschränkungen und sind daher für viele Projekte eine praktische Wahl.
Für Einsteiger können visuelle Tools wie Latenode den Lernprozess vereinfachen. Latenode ermöglicht das Experimentieren mit LangChain-Workflows in einer benutzerfreundlichen Drag-and-Drop-Oberfläche. Dieser Ansatz ist besonders für Anfänger hilfreich und bietet eine praktische Möglichkeit, Konzepte zu verstehen, bevor sie sich in den Code vertiefen.
Wenn Ihre Umgebung bereit ist, können Sie die Kernkomponenten von LangChain erkunden und mit der Entwicklung KI-gesteuerter Lösungen beginnen.
LangChain-Kernkomponenten
LangChain ist mit modularen Elementen aufgebaut, die es Entwicklern ermöglichen, KI-gesteuerte Arbeitsabläufe effizient. Wenn Sie die Kernkomponenten verstehen, können Sie das Potenzial für die Entwicklung vielfältiger und effektiver KI-Anwendungen freisetzen.
LLMs und Chat-Modelle
LangChain unterstützt zwei wichtige Arten von Sprachmodellen: LLMs (Große Sprachmodelle) und Chat-Modelle. Jedes dient einem einzigartigen Zweck und beeinflusst, wie Sie Eingabeaufforderungen entwerfen und Antworten verwalten.
LLMs sind für Textvervollständigungsaufgaben konzipiert. Sie eignen sich gut zum Generieren von Text, Zusammenfassen von Informationen oder Erstellen von Inhalten. Zum Beispiel:
<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)
Chat-Modelle, hingegen sind auf strukturierte Konversationen zugeschnitten. Sie übernehmen Rollen wie „System“, „Mensch“ und „Assistent“ und sind somit ideal für interaktive Dialoge:
<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)
Die Temperatur Der Parameter spielt eine entscheidende Rolle bei der Gestaltung der Ergebnisse. Niedrigere Werte (z. B. 0.1–0.3) führen zu präziseren und konsistenteren Antworten, während höhere Werte (z. B. 0.7–1.0) Kreativität und Variabilität fördern.
Als Nächstes untersuchen wir, wie Eingabeaufforderungsvorlagen die Interaktion mit diesen Modellen vereinfachen und standardisieren.
Eingabeaufforderungsvorlagen
Eingabeaufforderungsvorlagen sind eine praktische Möglichkeit, wiederverwendbare, strukturierte Eingabeaufforderungen zu erstellen. Sie ermöglichen es Ihnen, eine Vorlage einmal zu definieren und Variablen dynamisch einzufügen. Das spart Zeit und gewährleistet Konsistenz.
Eine grundlegende PromptTemplate funktioniert wie ein Python-F-String, bietet aber zusätzliche Validierung und Formatierung:
<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>)
Für Gespräche mit mehreren Rollen, ChatPromptTemplate bietet eine strukturierte Möglichkeit, dynamische Eingaben zu verarbeiten:
<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>
)
Eingabeaufforderung für wenige Schüsse ist eine weitere Technik, die Beispiele in die Vorlage einbezieht, um das Verständnis des Modells zu erleichtern:
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>
)
Eingabeaufforderungsvorlagen erleichtern die Verwaltung komplexer Arbeitsabläufe, indem sie die Art und Weise der Eingabe standardisieren.
Ketten
Ketten sind Workflows, die mehrere Komponenten miteinander verbinden, um komplexe Aufgaben auszuführen. Jeder Schritt baut auf dem Ergebnis des vorherigen auf und schafft so einen nahtlosen Prozess.
Das einfachste Beispiel ist ein LLMChain, das ein Sprachmodell mit einer Eingabeaufforderungsvorlage kombiniert:
<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>)
Für komplexere Arbeitsabläufe Sequentielle Ketten ermöglichen die Verknüpfung mehrerer Schritte. Sie könnten beispielsweise eine Blog-Gliederung erstellen, eine Einleitung schreiben und dann eine Schlussfolgerung formulieren:
<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>)
Routerketten Fügen Sie Entscheidungsfunktionen hinzu, indem Sie Eingaben basierend auf dem Inhalt an bestimmte Unterketten weiterleiten. Dies ist besonders hilfreich bei der Verarbeitung unterschiedlicher Eingabetypen, die maßgeschneiderte Antworten erfordern.
Für einen visuelleren Ansatz können Tools wie Latenode den Prozess der Gestaltung und Verwaltung dieser Workflows vereinfachen. Durch die Visualisierung der Kettenlogik können Sie Ihre KI-Lösungen besser verstehen und verfeinern.
Agenten und Tools
Agenten bringen Flexibilität in Ihre Arbeitsabläufe, indem sie Entscheidungen treffen und Aktionen dynamisch auswählen. Im Gegensatz zu Ketten, die einer festen Reihenfolge folgen, passen Agenten ihr Verhalten situationsabhängig an.
Zubehör sind Funktionen, die Agenten zur Interaktion mit externen Systemen nutzen können. LangChain bietet integrierte Tools, Sie können aber auch benutzerdefinierte Tools erstellen.
Hier ist ein Beispiel für ein integriertes Tool für die Google-Suche:
<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
)
Und hier ist ein benutzerdefiniertes Tool zum Berechnen prozentualer Änderungen:
<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
)
ReAct-Agenten (Argumentation und Handeln) kombinieren Entscheidungsfindung mit dem Einsatz von Werkzeugen. Sie analysieren die Situation, entscheiden sich für eine Aktion, setzen Werkzeuge ein und bewerten das Ergebnis:
<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)
Agenten und Tools bieten die für dynamische, reale Anwendungen erforderliche Anpassungsfähigkeit und machen LangChain zu einem vielseitigen Framework für die KI-Entwicklung.
sbb-itb-23997f1
Erstellen Ihrer ersten LangChain-Anwendung
Erfahren Sie, wie Sie eine LangChain-Anwendung von Grund auf erstellen, um Ihr Verständnis ihrer Funktionen zu vertiefen.
Grundlegender LLM-Aufruf
Ein einfacher Aufruf des Large Language Model (LLM) ist der Ausgangspunkt für die Erstellung komplexerer LangChain-Workflows. Nachfolgend sehen Sie ein Beispiel für eine einfache Textgenerierungsanwendung:
<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)
Bei einer Frage-Antwort-Anwendung können Sie die Interaktion mit einer Funktion strukturieren:
<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)
Dieser unkomplizierte Ansatz erstellt eine funktionale KI-Anwendung. Obwohl er einfach ist, dient er als Grundlage für komplexere Workflows, die Sie mithilfe mehrstufiger Ketten erweitern können.
Erstellen einer mehrstufigen Kette
Mehrstufige Ketten ermöglichen die sequenzielle Verarbeitung von Informationen, wobei jeder Schritt auf dem vorherigen aufbaut. Hier ist ein Beispiel für einen Blogbeitragsgenerator, der Themen skizziert, eine Einleitung schreibt und einen Call-to-Action hinzufügt:
<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)
Sie können auch Workflows erstellen, die mehrere Eingaben und Ausgaben in verschiedenen Phasen kombinieren:
<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>]
)
Diese mehrstufigen Ketten verwandeln einfache KI-Aufrufe in Workflows, die komplexe Aufgaben bewältigen und strukturierte und professionelle Ergebnisse ermöglichen. Sobald diese Ketten eingerichtet sind, können Sie Ihre Anwendung mit Funktionen wie Speicher und Agenten weiter verbessern.
Hinzufügen von Speicher und Agenten
Speicher und Agenten bringen Kontextbewusstsein und dynamische Entscheidungsfindung in LangChain-Anwendungen.
ConversationBufferMemory behält den Überblick über die gesamte Konversation und ist daher ideal für Chatbots oder interaktive Systeme:
<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)
Für Anwendungen, die eine effiziente Speicherverwaltung erfordern, GesprächZusammenfassungErinnerung verdichtet ältere Interaktionen:
<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
)
Agenten mit Werkzeugen ermöglichen dynamische Anwendungen, die mit externen Systemen interagieren und Echtzeitaufgaben ausführen:
<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)
Während LangChain Python ein robustes Programmier-Framework bietet, finden viele Entwickler die visuelle Oberfläche von Latenode eine hervorragende Ergänzung. Mit Latenode können Sie Workflows wie HTTP-Anforderung → OpenAI GPT-4 → Speicherablage → Antwortformatierung prototypisieren, ohne tief in den Code einzutauchen. So vertiefen Sie Ihr Verständnis dieser Konzepte beim Erstellen funktionaler Anwendungen.
Diese Kombination aus Speicher und Agenten ermöglicht Anwendungen, die den Kontext beibehalten, fundierte Entscheidungen treffen und nahtlos mit externen Systemen interagieren.
LangChain lernen mit Latenknoten Visuelle Workflows
Visuelle Workflows bieten eine einzigartige Möglichkeit, Agentenverhalten zu gestalten und zu verstehen, indem sie es grafisch darstellen. Dieser Ansatz ermöglicht die einfache Einbindung bedingter Verzweigungen und Schleifen. Während das Python-Framework von LangChain zweifellos robust ist, bietet der visuelle Workflow-Builder von Latenode eine praktische und intuitive Möglichkeit, KI-Konzepte zu verstehen und funktionale Anwendungen zu erstellen. Er vereinfacht komplexe Ideen und macht sie zugänglicher, insbesondere für Einsteiger in KI-Workflows.
Visual Workflow Builder für LangChain
Die Drag-and-Drop-Oberfläche von Latenode verwandelt die abstrakten Konzepte von LangChain in klare, visuelle Arbeitsabläufe. Anstatt sich mit der Python-Syntax herumzuschlagen, können Sie sich auf die Datenübertragung zwischen Komponenten konzentrieren.
In diesem System werden LangChain-Elemente als miteinander verbundene Knoten dargestellt. Beispielsweise ein HTTP-Anfrage Knoten kann einen OpenAI GPT-4 Knoten. Die Ausgabe könnte dann zu einem Speicher Knoten und durchlaufen schließlich einen Antwortformatierung Knoten zur Präsentation. Dieses Setup spiegelt das wider, was Sie normalerweise in Python codieren würden, entfernt jedoch die Syntaxbarrieren und ist daher besonders für Anfänger nützlich.
Die visuelle Darstellung der Plattform erweckt die Konzepte von LangChain zum Leben und ermöglicht Lernenden, die Funktionsweise von KI-Workflows zu verstehen. Unterstützte Integrationen und KI-Modelle geben Ihnen die Freiheit, mit Tools zu experimentieren, die Sie später in realen Anwendungen einsetzen werden. Zum Beispiel beim Erkunden von LangChains ConversationBufferMemorykönnen Sie den Gesprächsverlauf von einer Interaktion zur nächsten visuell nachvollziehen. Diese praktische Klarheit macht abstrakte Ideen greifbarer und beschleunigt das Lernen im Vergleich zu herkömmlichen Programmiermethoden, bei denen das Debuggen von Speicherproblemen oft umfangreiche Protokollierungen erfordert.
Erstellen visueller LangChain-Prototypen
Mit Latenode können Sie von Anfang an funktionale Prototypen erstellen. So können Sie beispielsweise einen mehrstufigen Blog-Post-Generator als visuellen Workflow replizieren: HTTP-Webhook → OpenAI GPT-4 (Gliederung) → OpenAI GPT-4 (Einführung) → OpenAI GPT-4 (Aufruf zum Handeln) → Google Blätter zur Aufbewahrung.
Dieser visuelle Ansatz macht die Logik hinter Workflows übersichtlich. Bedingte Abläufe und Datentransformationen werden durch einzelne Knoten dargestellt, was das Verständnis der einzelnen Schritte erleichtert. Beim Erstellen eines Wetteragenten können Sie beispielsweise einen Wetter-API Knoten zu an OpenAI GPT-4 Knoten und verwenden Sie dann Logikknoten, um die Ausgabe basierend auf bestimmten Bedingungen zu verzweigen.
Latenode enthält außerdem eine KI-Code-Copilot, das JavaScript-Snippets generiert, die mit den Python-Mustern von LangChain übereinstimmen. Diese Funktion schließt die Lücke zwischen visuellen Workflows und Programmierung und hilft Lernenden, sowohl die konzeptionelle als auch die technische Seite ihrer Projekte zu verstehen. Viele Anwender finden diesen dualen Ansatz hilfreich, um Workflows zu verstehen, bevor sie sie in Python implementieren. Auch das Debuggen wird vereinfacht, da das visuelle Format es Ihnen ermöglicht, den Status des Agenten und den Entscheidungsprozess bei jedem Schritt zu überwachen.
Vorteile von Latenode für Anfänger
Latenode bietet mehrere Vorteile für Einsteiger in LangChain. Ein großer Vorteil ist die Möglichkeit, schnell zu iterieren. Bei der traditionellen Python-Entwicklung müssen oft Umgebungen eingerichtet, Abhängigkeiten verwaltet und Syntaxfehler behoben werden, bevor Workflows überhaupt getestet werden können. Latenode beseitigt diese Hindernisse und ermöglicht Ihnen, die Architektur von LangChain direkt zu verstehen.
Die Plattform ist auch für Experimente kostengünstig. Das ausführungsbasierte Preismodell berechnet nur die tatsächliche Laufzeit, nicht pro API-Aufruf. Dies macht sie ideal für Tests während der Lernphase. Die Freier Plan, das 300 Ausführungsguthaben pro Monat umfasst, bietet reichlich Raum zum Experimentieren und Prototyping.
Neben dem Erlernen von LangChain-Konzepten führt Latenode Sie in reale Integrationen ein. Sie können mit Tools wie Notion, Google Blätter, Stripe und WhatsApp, und sammeln Sie praktische Erfahrungen mit produktionsreifen Anwendungen. Diese praktische Erfahrung bereitet Sie auf die Entwicklung betriebsbereiter Lösungen vor.
Latenode erweitert die Möglichkeiten von LangChain durch die Headless-Browser-Funktion auch auf die Webautomatisierung. Erstellen Sie Workflows, die Daten extrahieren, Formulare ausfüllen und mit Webanwendungen interagieren, während Sie die Speicher- und Agentenmuster von LangChain anwenden. Diese praxisnahe Anwendung schließt die Lücke zwischen theoretischen Konzepten und praktischen Anwendungsfällen.
Schließlich fördert das visuelle Format von Latenode die Zusammenarbeit. Teams können Arbeitsabläufe problemlos überprüfen, ändern und verstehen, ohne umfassende Python-Kenntnisse zu benötigen. Dies macht es zu einem hervorragenden Tool sowohl für Bildungseinrichtungen als auch für Entwicklungsteams, das gemeinsames Lernen und schnellere Fortschritte fördert.
Nächste Schritte: Vom Lernen zur Produktion
Kenntnisse in LangChain Python eröffnen Ihnen die Möglichkeit, fortgeschrittene KI-Anwendungen zu entwickeln. Der Übergang vom Lernen zur Produktion erfordert jedoch sorgfältige Planung und die richtigen Tools, um den Erfolg sicherzustellen.
Ressourcen für fortgeschrittenes Lernen
Die LangChain-Dokumentation ist eine wichtige Ressource für den Einstieg in fortgeschrittene Themen. Es bietet detaillierte Anleitungen zur komplexen Kettenzusammensetzung und zu Streaming-Funktionen. Darüber hinaus ist die LangSmith Integrationsdokumentation ist von unschätzbarem Wert für das Debuggen und Überwachen von Anwendungen in Produktionsumgebungen.
Für praktische Einblicke, GitHub-Repositories bieten Beispiele aus der Praxis, die über grundlegende Tutorials hinausgehen. Die offizielle LangChain-Vorlagen Das Repository ist besonders hilfreich und bietet produktionsreife Starterprojekte für Aufgaben wie Dokument-Q&A-Systeme, SQL-Agenten und multimodale Anwendungen. Diese Vorlagen betonen kritische Aspekte wie Fehlerbehandlung, Protokollierung und Konfigurationsmanagement, die in Ressourcen für Anfänger oft übersehen werden.
Sich mit Community-Ressourcen Auch Communitys wie der LangChain Discord-Server und Reddit-Communitys können hilfreich sein. Entwickler tauschen sich regelmäßig über ihre Erfahrungen mit Produktionsherausforderungen aus und geben Tipps zur Leistungsoptimierung und Kostenverwaltung für API-lastige Anwendungen.
Für diejenigen, die ihr Fachwissen vertiefen möchten, ist die LangChain-Kochbuch ist ein Muss. Es enthält fortgeschrittene Techniken zur Speicherverwaltung, zur Integration von Tools und zur Orchestrierung von Agenten. Abschnitte zu benutzerdefinierten Tools und Multi-Agenten-Systemen sind besonders nützlich für die Entwicklung komplexer und skalierbarer Geschäftslösungen.
Diese Ressourcen bieten die erforderliche Wissensbasis für die Überführung Ihrer LangChain-Projekte von der Entwicklung in die Produktion.
Umstellung auf produktionsreife Lösungen
Um Ihre Anwendung in die Produktion zu bringen, müssen mehrere kritische Aspekte berücksichtigt werden, darunter Fehlerbehandlung, Skalierbarkeit und Überwachung.
Ratenbegrenzung wird unerlässlich bei der Arbeit mit APIs wie OpenAI oder AnthropischDas Überschreiten von Kontingenten kann zu Dienstunterbrechungen führen und das Benutzererlebnis beeinträchtigen.
Umweltmanagement Auch die Speicherung von API-Schlüsseln gewinnt an Bedeutung. Neben der einfachen Speicherung von API-Schlüsseln profitieren Produktionsumgebungen von strukturierten Konfigurationen, die auf Entwicklungs-, Staging- und Produktionsumgebungen zugeschnitten sind. Sichere Tools zur Verwaltung von Anmeldeinformationen, wie z. B. AWS Secrets Manager or Azure Key Vault, kann zum Schutz vertraulicher Informationen beitragen.
Protokollierung und Beobachtbarkeit sind der Schlüssel zum Verständnis der Anwendungsleistung und der Benutzerinteraktionen. Während LangSmith integriertes Tracing für LangChain-Apps bietet, implementieren viele Teams auch benutzerdefinierte Protokollierung, um geschäftsspezifische Kennzahlen zu verfolgen.
Mit zunehmender Nutzung Kostenoptimierung wird zur Priorität. Techniken wie Caching, schnelle Verfeinerung und die Auswahl der richtigen Modelle können dazu beitragen, die Kosten zu senken, ohne die Funktionalität zu beeinträchtigen.
Das Testen von KI-Anwendungen erfordert einen anderen Ansatz als bei herkömmlicher Software. Bewertungsrahmen sollten Aspekte wie Antwortqualität, sachliche Richtigkeit und Konsistenz messen. Einige Teams verwenden auch Golden Datasets für Regressionstests, um sicherzustellen, dass ihre Anwendungen auch bei der Weiterentwicklung zuverlässig bleiben.
Für Teams, die diese Produktionsherausforderungen vereinfachen möchten, bietet Latenode eine leistungsstarke Lösung zur effizienten Automatisierung und Verwaltung von Arbeitsabläufen.
Verwenden von Latenode für die Geschäftsautomatisierung
Latenode schließt die Lücke zwischen Prototypen und produktionsreifen Lösungen und beseitigt einen Großteil der Infrastrukturkomplexität.
Seine eingebaute Datenbank ermöglicht es Entwicklern, Gesprächsverläufe, Benutzereinstellungen und Anwendungszustände direkt in Workflows zu speichern. Dadurch entfällt die Notwendigkeit externer Datenspeicher, was die Architektur vereinfacht und die Bereitstellung beschleunigt.
Die Headless-Browser-Automatisierung Die Funktion erweitert die Fähigkeiten von LangChain auf webbasierte Workflows. Dies ermöglicht Unternehmen die Erstellung von KI-Agenten, die mit Webanwendungen interagieren – Formulare ausfüllen, Daten extrahieren und den Konversationskontext mit den Speichersystemen von LangChain aufrechterhalten.
Mit über 300 App-IntegrationenLatenode vereinfacht die Automatisierung komplexer Geschäftsprozesse. Ein Produktionsworkflow könnte beispielsweise Folgendes integrieren: Salesforce, OpenAI GPT-4, Slackund Google Sheets zur Automatisierung von Aufgaben wie Lead-Qualifizierung und Follow-ups. Diese Workflows, die normalerweise eine umfangreiche individuelle Python-Entwicklung erfordern würden, können mit der Plattform von Latenode schnell erstellt werden.
Für Unternehmen, die über das Experimentieren hinaus skalieren, bietet Latenode Unternehmensplan beginnt bei 299 US-Dollar/Monat und bietet unbegrenzte Ausführungsguthaben und einen 60-tägigen Protokollverlauf. Organisationen, die mit sensiblen Daten umgehen, können sich auch für die Self-Hosting-Option, um die Einhaltung interner und gesetzlicher Anforderungen sicherzustellen.
Viele Teams verfolgen einen hybriden Ansatz und nutzen Latenode als Rückgrat für die Produktionsautomatisierung, während sie gleichzeitig benutzerdefinierte LangChain-Python-Anwendungen für spezialisierte KI-Logik pflegen. Diese Strategie kombiniert die Zuverlässigkeit und Integrationsfähigkeit von Latenode mit der Flexibilität maßgeschneiderter Entwicklung und liefert robuste und skalierbare Lösungen.
FAQs
Warum ist LangChain für die KI-Entwicklung eine bessere Wahl als herkömmliche API-Aufrufe?
LangChain ist im Vergleich zu herkömmlichen API-Aufrufen ein wertvolles Tool für die Erstellung von KI-Anwendungen. Es unterstützt strukturierte Arbeitsabläufe Durch Funktionen wie Speicherverwaltung, mehrstufiges Denken und nahtlose Tool-Integration können Entwickler KI-Systeme entwickeln, die sowohl fortschrittlich als auch skalierbar sind.
Durch die Optimierung der Orchestrierung komplexer Workflows trägt LangChain zur Verkürzung der Entwicklungszeit bei und fördert gleichzeitig die Modularität und Wiederverwendbarkeit von Komponenten. Dies macht es zu einem hervorragenden Framework für die Erstellung moderner KI-Anwendungen, insbesondere solcher, die intelligente Entscheidungsfindung oder dynamische Benutzerinteraktionen erfordern.
Wie bewältigt LangChain Einrichtungsprobleme auf verschiedenen Betriebssystemen?
Die Einrichtung von LangChain kann manchmal knifflig sein, da sie von Ihrem Betriebssystem und Ihrer Hardware abhängt. Zu den häufigsten Herausforderungen gehören die Verwaltung von Abhängigkeiten, die Lösung von Paketkompatibilitätsproblemen und die Sicherstellung der Unterstützung hardwarespezifischer Anforderungen, wie z. B. GPUs für erweiterte Aufgaben.
Um den Prozess zu vereinfachen, gibt es Schritt-für-Schritt-Anleitungen für bestimmte Systeme wie macOS oder Windows. Diese Anleitungen behandeln häufige Einrichtungsprobleme und bieten klare Anweisungen, auch für neuere Geräte wie das MacBook Pro M2. Mithilfe dieser Ressourcen können Sie den Installationsprozess optimieren und mit minimalem Aufwand mit LangChain arbeiten.
Können Anfänger den visuellen Workflow-Builder von Latenode verwenden, um LangChain-Anwendungen ohne fortgeschrittene Programmierkenntnisse zu erstellen?
Anfänger finden Latenodes visueller Workflow-Builder ein zugängliches Tool zum Erstellen und Prototyping von LangChain-Anwendungen, auch ohne fortgeschrittene Programmierkenntnisse. Die Plattform Drag-and-Drop-Oberfläche vereinfacht den Prozess der Gestaltung von KI-Workflows und ermöglicht es Benutzern, das Verständnis von Konzepten dem Umgang mit komplexer Programmierung vorzuziehen.
Durch seinen visuellen Mapping-Ansatz hilft Latenode neuen Benutzern, LangChain-Funktionen wie Ketten, Agenten und Speicher schnell zu verstehen und zu implementieren. Diese praktische Methode beschleunigt das Lernen und liefert sofortige Ergebnisse. Damit ist sie ein hervorragender Ausgangspunkt für KI-Neulinge.
Ähnliche Artikel
