Skip to main content Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/BEKO2210/Firstbrain --skill langchain-architectureO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
name langchain-architecture description Master the LangChain framework for building sophisticated LLM applications with agents, chains, memory, and tool integration. type skill created 2026-02-27T00:00:00.000Z domain ai-ml category llm-agents risk unknown source community tags ["skill","ai-ml","llm-agents","langchain","architecture"]
LangChain Architecture
Master the LangChain framework for building sophisticated LLM applications with agents, chains, memory, and tool integration.
Do not use this skill when
The task is unrelated to langchain architecture
You need a different domain or tool outside this scope
Instructions
Clarify goals, constraints, and required inputs.
Apply relevant best practices and validate outcomes.
Provide actionable steps and verification.
If detailed examples are required, open resources/implementation-playbook.md.
Use this skill when
Building autonomous AI agents with tool access
Implementing complex multi-step LLM workflows
Managing conversation memory and state
Integrating LLMs with external data sources and APIs
Creating modular, reusable LLM application components
Implementing document processing pipelines
Building production-grade LLM applications
Core Concepts
1. Agents
Autonomous systems that use LLMs to decide which actions to take.
Agent Types:
ReAct : Reasoning + Acting in interleaved mannerOpenAI Functions : Leverages function calling APIStructured Chat : Handles multi-input toolsConversational : Optimized for chat interfacesSelf-Ask with Search : Decomposes complex queries
2. Chains
Sequences of calls to LLMs or other utilities.
Chain Types:
LLMChain : Basic prompt + LLM combinationSequentialChain : Multiple chains in sequenceRouterChain : Routes inputs to specialized chainsTransformChain : Data transformations between stepsMapReduceChain : Parallel processing with aggregation
3. Memory
Systems for maintaining context across interactions.
Memory Types:
ConversationBufferMemory : Stores all messagesConversationSummaryMemory : Summarizes older messagesConversationBufferWindowMemory : Keeps last N messages
EntityMemory
VectorStoreMemory : Semantic similarity retrieval
4. Document Processing Loading, transforming, and storing documents for retrieval.
Document Loaders : Load from various sourcesText Splitters : Chunk documents intelligentlyVector Stores : Store and retrieve embeddingsRetrievers : Fetch relevant documentsIndexes : Organize documents for efficient access
5. Callbacks Hooks for logging, monitoring, and debugging.
Request/response logging
Token usage tracking
Latency monitoring
Error handling
Custom metrics collection
Quick Start from langchain.agents import AgentType, initialize_agent, load_tools
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
llm = OpenAI(temperature=0 )
tools = load_tools(["serpapi" , "llm-math" ], llm=llm)
memory = ConversationBufferMemory(memory_key="chat_history" )
agent = initialize_agent(
tools,
llm,
agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
memory=memory,
verbose=True
)
result = agent.run("What's the weather in SF? Then calculate 25 * 4" )
Architecture Patterns
Pattern 1: RAG with LangChain from langchain.chains import RetrievalQA
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
loader = TextLoader('documents.txt' )
documents = loader.load()
text_splitter = CharacterTextSplitter(chunk_size=1000 , chunk_overlap=200 )
texts = text_splitter.split_documents(documents)
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(texts, embeddings)
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff" ,
retriever=vectorstore.as_retriever(),
return_source_documents=True
)
result = qa_chain({"query" : "What is the main topic?" })
Pattern 2: Custom Agent with Tools from langchain.agents import Tool, AgentExecutor
from langchain.agents.react.base import ReActDocstoreAgent
from langchain.tools import tool
@tool
def search_database (query: str ) -> str :
"""Search internal database for information."""
return f"Results for: {query} "
@tool
def send_email (recipient: str , content: str ) -> str :
"""Send an email to specified recipient."""
return f"Email sent to {recipient} "
tools = [search_database, send_email]
agent = initialize_agent(
tools,
llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)
Pattern 3: Multi-Step Chain from langchain.chains import LLMChain, SequentialChain
from langchain.prompts import PromptTemplate
extract_prompt = PromptTemplate(
input_variables=["text" ],
template="Extract key entities from: {text}\n\nEntities:"
)
extract_chain = LLMChain(llm=llm, prompt=extract_prompt, output_key="entities" )
analyze_prompt = PromptTemplate(
input_variables=["entities" ],
template="Analyze these entities: {entities}\n\nAnalysis:"
)
analyze_chain = LLMChain(llm=llm, prompt=analyze_prompt, output_key="analysis" )
summary_prompt = PromptTemplate(
input_variables=["entities" , "analysis" ],
template="Summarize:\nEntities: {entities}\nAnalysis: {analysis}\n\nSummary:"
)
summary_chain = LLMChain(llm=llm, prompt=summary_prompt, output_key="summary" )
overall_chain = SequentialChain(
chains=[extract_chain, analyze_chain, summary_chain],
input_variables=["text" ],
output_variables=["entities" , "analysis" , "summary" ],
verbose=True
)
Memory Management Best Practices
Choosing the Right Memory Type
from langchain.memory import ConversationBufferMemory
memory = ConversationBufferMemory()
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(llm=llm)
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=5 )
from langchain.memory import ConversationEntityMemory
memory = ConversationEntityMemory(llm=llm)
from langchain.memory import VectorStoreRetrieverMemory
memory = VectorStoreRetrieverMemory(retriever=retriever)
Callback System
Custom Callback Handler from langchain.callbacks.base import BaseCallbackHandler
class CustomCallbackHandler (BaseCallbackHandler ):
def on_llm_start (self, serialized, prompts, **kwargs ):
print (f"LLM started with prompts: {prompts} " )
def on_llm_end (self, response, **kwargs ):
print (f"LLM ended with response: {response} " )
def on_llm_error (self, error, **kwargs ):
print (f"LLM error: {error} " )
def on_chain_start (self, serialized, inputs, **kwargs ):
print (f"Chain started with inputs: {inputs} " )
def on_agent_action (self, action, **kwargs ):
print (f"Agent taking action: {action} " )
agent.run("query" , callbacks=[CustomCallbackHandler()])
Testing Strategies import pytest
from unittest.mock import Mock
def test_agent_tool_selection ():
mock_llm = Mock()
mock_llm.predict.return_value = "Action: search_database\nAction Input: test query"
agent = initialize_agent(tools, mock_llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
result = agent.run("test query" )
assert "search_database" in str (mock_llm.predict.call_args)
def test_memory_persistence ():
memory = ConversationBufferMemory()
memory.save_context({"input" : "Hi" }, {"output" : "Hello!" })
assert "Hi" in memory.load_memory_variables({})['history' ]
assert "Hello!" in memory.load_memory_variables({})['history' ]
Performance Optimization
1. Caching from langchain.cache import InMemoryCache
import langchain
langchain.llm_cache = InMemoryCache()
2. Batch Processing
from langchain.document_loaders import DirectoryLoader
from concurrent.futures import ThreadPoolExecutor
loader = DirectoryLoader('./docs' )
docs = loader.load()
def process_doc (doc ):
return text_splitter.split_documents([doc])
with ThreadPoolExecutor(max_workers=4 ) as executor:
split_docs = list (executor.map (process_doc, docs))
3. Streaming Responses from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
llm = OpenAI(streaming=True , callbacks=[StreamingStdOutCallbackHandler()])
Resources
references/agents.md : Deep dive on agent architecturesreferences/memory.md : Memory system patternsreferences/chains.md : Chain composition strategiesreferences/document-processing.md : Document loading and indexingreferences/callbacks.md : Monitoring and observabilityassets/agent-template.py : Production-ready agent templateassets/memory-config.yaml : Memory configuration examplesassets/chain-example.py : Complex chain examples
Common Pitfalls
Memory Overflow : Not managing conversation history lengthTool Selection Errors : Poor tool descriptions confuse agentsContext Window Exceeded : Exceeding LLM token limitsNo Error Handling : Not catching and handling agent failuresInefficient Retrieval : Not optimizing vector store queries
Production Checklist
Connections
Domain: [[KI & Machine Learning]]Kategorie: [[LLM & KI-Agenten]]Navigation: [[Skills Uebersicht]], [[Home]] 