LangChain | 1byteone - Java Backend / AI Application Developer

LangChain Core Architecture: Runnables, Models, and Composable Chains

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard: LangChain — LangChain Core Architecture.

LangChain is more than a wrapper around a model. Its useful abstraction is a composable runtime: once a prompt, model, and parser are treated as Runnable stages, invocation, batching, streaming, and tracing follow the same shape.

Core mental model

A typical path is input dict → ChatPromptTemplate → ChatModel → StrOutputParser. Each node owns a contract; the chain only composes them, making model swaps and isolated tests straightforward.

Key mechanics

The | operator describes data flow. Use invoke for one request, batch for bulk work, and stream for low time-to-first-token. Production code should validate at boundaries and enforce timeouts instead of swallowing exceptions.

Python example

from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

prompt = ChatPromptTemplate.from_messages([
 ("system", "You are a concise technical assistant."),
 ("human", "Explain in three points: {question}"),
])
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
chain = prompt | model | StrOutputParser()
answer = chain.invoke({"question": "What is idempotency?"})

Course focus

This article turns the whiteboard into explicit engineering boundaries: define inputs and outputs first, then decide how state, failures, and observability work. The examples use Python and focus on durable design principles rather than a particular provider version; verify APIs against the documentation for your installed dependencies.

Engineering practice

Keep business rules in the application layer instead of hiding them in untestable prompts or route handlers.
Add timeouts, bounded retries, and idempotency keys to external calls; retries are not a complete error strategy.
Record a request id, latency, input version, model/index version, and outcome without logging sensitive raw content.
Use a small fixed regression set first, then monitor quality and cost with sampled production traffic.

Common mistakes

Drawing only the happy path and omitting timeouts, empty results, rate limits, and rollback paths.
Letting one function parse input, call providers, build prompts, and persist data.
Replacing typed contracts with string conventions that can only be verified by manual integration.

Production checklist

Inputs, outputs, and error responses have explicit schemas
External dependencies have timeouts, bounded retries, rate limits, and fallbacks
Logs, metrics, and traces can be correlated to one request
Critical paths have unit tests, integration tests, and offline evaluation samples
Secrets, user content, and provider responses follow least-privilege and privacy rules

Practice

Implement the smallest loop shown on the whiteboard. Inject a timeout, an empty result, and a malformed payload, then check whether the system remains stable and diagnosable. Add one metric that proves your optimization improved quality or latency.

Hands-on exercise

Split the chain into replaceable render_prompt, call_model, and parse_output stages, and test the parser without a network call. When the model changes, tests should assert the final contract rather than provider-specific response fields.

Conclusion

An AI feature becomes maintainable when every arrow on the whiteboard maps to an input, an output, and a failure strategy.

LangChain Memory: Designing Controlled Multi-Turn State

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard: LangChain — LangChain Memory.

The challenge of multi-turn chat is not putting every message back into the prompt. It is deciding which facts to retain, for how long, and who can delete them. Memory is explicit data, not an implicit model capability.

Core mental model

Short-term memory serves the current conversation, summaries compress earlier turns, and long-term memory stores consented preferences. All three need a conversation id, tenant isolation, and retention policy.

Key mechanics

Budget tokens before deciding whether to truncate or summarize. Filter PII and deduplicate before writing long-term memory. When reading memory, include source and timestamp so stale facts do not override newer ones.

Python example

from dataclasses import dataclass
from datetime import datetime

@dataclass
class MemoryItem:
 conversation_id: str
 text: str
 source: str
 created_at: datetime

def build_context(history: list[MemoryItem], max_chars: int = 6000) -> str:
 selected, size = [], 0
 for item in reversed(history):
 if size + len(item.text) > max_chars: break
 selected.append(f"[{item.source}] {item.text}")
 size += len(item.text)
 return "\n".join(reversed(selected))

Course focus

Engineering practice

Keep business rules in the application layer instead of hiding them in untestable prompts or route handlers.
Add timeouts, bounded retries, and idempotency keys to external calls; retries are not a complete error strategy.
Record a request id, latency, input version, model/index version, and outcome without logging sensitive raw content.
Use a small fixed regression set first, then monitor quality and cost with sampled production traffic.

Common mistakes

Drawing only the happy path and omitting timeouts, empty results, rate limits, and rollback paths.
Letting one function parse input, call providers, build prompts, and persist data.
Replacing typed contracts with string conventions that can only be verified by manual integration.

Production checklist

Inputs, outputs, and error responses have explicit schemas
External dependencies have timeouts, bounded retries, rate limits, and fallbacks
Logs, metrics, and traces can be correlated to one request
Critical paths have unit tests, integration tests, and offline evaluation samples
Secrets, user content, and provider responses follow least-privilege and privacy rules

Practice

Hands-on exercise

Implement three context layers—recent turns, a conversation summary, and user preferences—and record which message ids each summary covers. When deleting a conversation, verify caches, vector stores, and audit copies are all removed.

Conclusion

An AI feature becomes maintainable when every arrow on the whiteboard maps to an input, an output, and a failure strategy.

LangChain Prompt Chains: Treat Prompts as Maintainable Programs

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard: LangChain — LangChain Prompt Chains.

A prompt is not an untracked block of text buried in code. It is a program component that needs versioning, input validation, and regression tests. This article builds a reliable template, structured input, model, and parser flow.

Core mental model

A stable Prompt Chain separates system rules, the human task, and conversation context. Variable names should carry semantics; avoid letting a generic text value change meaning across stages.

Key mechanics

Render and inspect the prompt before calling the model. Budget long context and delimit user text; never concatenate user-controlled content into system instructions.

Python example

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
 ("system", "Answer only from context; say when it is insufficient."),
 ("human", "<context>\n{context}\n</context>\nQuestion: {question}"),
])
chain = prompt | model | StrOutputParser()
print(chain.invoke({"context": "An idempotent request does not create extra side effects when repeated.", "question": "What problem does idempotency solve?"}))

Course focus

Engineering practice

Keep business rules in the application layer instead of hiding them in untestable prompts or route handlers.
Add timeouts, bounded retries, and idempotency keys to external calls; retries are not a complete error strategy.
Record a request id, latency, input version, model/index version, and outcome without logging sensitive raw content.
Use a small fixed regression set first, then monitor quality and cost with sampled production traffic.

Common mistakes

Drawing only the happy path and omitting timeouts, empty results, rate limits, and rollback paths.
Letting one function parse input, call providers, build prompts, and persist data.
Replacing typed contracts with string conventions that can only be verified by manual integration.

Production checklist

Inputs, outputs, and error responses have explicit schemas
External dependencies have timeouts, bounded retries, rate limits, and fallbacks
Logs, metrics, and traces can be correlated to one request
Critical paths have unit tests, integration tests, and offline evaluation samples
Secrets, user content, and provider responses follow least-privilege and privacy rules

Practice

Hands-on exercise

Add a prompt_version, keep 20 fixed questions as a regression set, and compare factuality, abstention rate, and token usage before and after each prompt change.

Conclusion

An AI feature becomes maintainable when every arrow on the whiteboard maps to an input, an output, and a failure strategy.

LangChain Tool-Calling Agents: Separate Decisions from Execution

Fri, 21 Aug 2026 00:00:00 +0000

Whiteboard: LangChain — LangChain Tool-Calling Agents.

An agent should not give a model direct access to your system. The model proposes a structured tool intent; the application validates and executes it. The central boundary is: the model decides, the application executes.

Core mental model

The loop is Think → Call → Observe, while the host application controls iteration limits, tool allowlists, parameter validation, and permissions. Good descriptions improve selection but are not security policies.

Key mechanics

Tools should return machine-readable success or failure results; do not expose raw stack traces to the model or user. Require explicit confirmation for writes and emit an audit event for every call.

Python example

from langchain_core.tools import tool

@tool
def get_weather(city: str) -> dict:
 """Return current weather for an allowed city."""
 if city not in {"Shanghai", "Beijing"}:
 return {"ok": False, "error": "city_not_allowed"}
 return {"ok": True, "city": city, "celsius": 26}

llm_with_tools = model.bind_tools([get_weather])
message = llm_with_tools.invoke("Is Shanghai good for a run today?")
if message.tool_calls:
 result = get_weather.invoke(message.tool_calls[0]["args"])

Course focus

Engineering practice

Keep business rules in the application layer instead of hiding them in untestable prompts or route handlers.
Add timeouts, bounded retries, and idempotency keys to external calls; retries are not a complete error strategy.
Record a request id, latency, input version, model/index version, and outcome without logging sensitive raw content.
Use a small fixed regression set first, then monitor quality and cost with sampled production traffic.

Common mistakes

Drawing only the happy path and omitting timeouts, empty results, rate limits, and rollback paths.
Letting one function parse input, call providers, build prompts, and persist data.
Replacing typed contracts with string conventions that can only be verified by manual integration.

Production checklist

Inputs, outputs, and error responses have explicit schemas
External dependencies have timeouts, bounded retries, rate limits, and fallbacks
Logs, metrics, and traces can be correlated to one request
Critical paths have unit tests, integration tests, and offline evaluation samples
Secrets, user content, and provider responses follow least-privilege and privacy rules

Practice

Hands-on exercise

Add one read-only search tool and one side-effecting refund tool. Auto-run the first, return requires_confirmation for the second, and test that the agent cannot bypass confirmation.

Conclusion

An AI feature becomes maintainable when every arrow on the whiteboard maps to an input, an output, and a failure strategy.

Building AI Agents with LangChain: Tool Integration and Multi-Turn Conversations

Fri, 10 Jul 2026 00:00:00 +0000

AI agents are revolutionizing how we build intelligent applications. Unlike simple chatbots, agents can use tools, maintain context, and make decisions. This guide covers building production-ready agents with LangChain.

Above: LangChain Agent architecture — User Input → Reasoning Loop → Tool Calling → Multi-turn Conversation

What are AI Agents?

Agents combine LLMs with tools and reasoning capabilities:

User Input → Agent (Reasoning) → Tool Selection → Tool Execution → Response

Key characteristics:

Tool Usage - Can interact with external systems
Reasoning - Decides which tools to use and when
Memory - Maintains context across interactions
Autonomy - Can chain multiple actions together

LangChain Agent Framework

LangChain provides a powerful framework for building agents:

from langchain.agents import create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

# Initialize LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)

# Define prompt
prompt = ChatPromptTemplate.from_messages([
 ("system", "You are a helpful assistant with access to tools."),
 ("human", "{input}"),
 ("placeholder", "{agent_scratchpad}")
])

# Create agent
agent = create_openai_tools_agent(llm, tools, prompt)

Custom Tool Development

Build tools specific to your use case:

from langchain_core.tools import tool
from typing import Optional

@tool
def search_knowledge_base(query: str) -> str:
 """Search the private knowledge base for information."""
 # Implementation here
 results = vector_store.similarity_search(query, k=3)
 return "\n".join([doc.page_content for doc in results])

@tool
def get_product_info(product_id: str) -> str:
 """Get detailed product information by ID."""
 # Database query here
 product = db.get_product(product_id)
 return f"Product: {product.name}, Price: {product.price}"

# Register tools
tools = [search_knowledge_base, get_product_info]

Tool Best Practices

Clear Descriptions - Help the agent understand when to use each tool
Error Handling - Gracefully handle tool failures
Input Validation - Validate inputs before processing
Rate Limiting - Prevent abuse of external APIs

Memory Management

Implement conversation memory for context persistence:

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

# Initialize memory
memory = ConversationBufferMemory(return_messages=True)

# Create conversation chain
conversation = ConversationChain(
 llm=llm,
 memory=memory,
 verbose=True
)

# Use in agent
agent = create_openai_tools_agent(
 llm, tools, prompt,
 memory=memory
)

Memory Types

Type	Use Case	Trade-offs
Buffer	Simple conversations	Limited context
Summary	Long conversations	Information loss
Vector	Semantic search	Storage overhead
Entity	Entity tracking	Complexity

Multi-turn Conversations

Handle complex conversation flows:

from langchain.agents import AgentExecutor

# Create agent executor
agent_executor = AgentExecutor(
 agent=agent,
 tools=tools,
 verbose=True,
 max_iterations=10, # Prevent infinite loops
 handle_parsing_errors=True
)

# Conversation with context
def chat(user_input: str, conversation_id: str):
 # Load conversation history
 history = load_conversation_history(conversation_id)

 # Run agent
 result = agent_executor.invoke({
 "input": user_input,
 "chat_history": history
 })

 # Save to history
 save_conversation_history(conversation_id, user_input, result["output"])

 return result["output"]

Production Deployment

1. FastAPI Integration

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class ChatRequest(BaseModel):
 message: str
 conversation_id: str

class ChatResponse(BaseModel):
 response: str
 conversation_id: str

@app.post("/chat", response_model=ChatResponse)
async def chat_endpoint(request: ChatRequest):
 try:
 response = chat(request.message, request.conversation_id)
 return ChatResponse(
 response=response,
 conversation_id=request.conversation_id
 )
 except Exception as e:
 raise HTTPException(status_code=500, detail=str(e))

2. Streaming Responses

from fastapi.responses import StreamingResponse

@app.post("/chat/stream")
async def chat_stream(request: ChatRequest):
 async def generate():
 async for event in agent_executor.astream_events(
 {"input": request.message},
 version="v1"
 ):
 if event["event"] == "on_chat_model_stream":
 content = event["data"]["chunk"].content
 if content:
 yield f"data: {content}\n\n"
 yield "data: [DONE]\n\n"

 return StreamingResponse(generate(), media_type="text/event-stream")

3. Error Handling

@app.middleware("http")
async def error_handler(request, call_next):
 try:
 response = await call_next(request)
 return response
 except Exception as e:
 logger.error(f"Agent error: {e}")
 return JSONResponse(
 status_code=500,
 content={"error": "Internal server error"}
 )

Real-World Example: Agricultural Q&A Agent

Here’s how I built an agricultural knowledge base agent:

from langchain.agents import create_openai_tools_agent
from langchain.tools import Tool

# Define agricultural tools
tools = [
 Tool(
 name="SearchKnowledgeBase",
 func=search_agricultural_knowledge,
 description="Search private agricultural manuals for crop diseases, treatments, and best practices"
 ),
 Tool(
 name="GeneralAgriculturalKnowledge",
 func=get_general_knowledge,
 description="Get general agricultural information when private knowledge base doesn't have the answer"
 )
]

# System prompt emphasizing private data priority
system_prompt = """You are an agricultural expert assistant.

IMPORTANT: Always search the private knowledge base FIRST. Only use general knowledge if the private search returns no relevant results.

When answering:
1. Cite the source document when possible
2. Be specific about crop names, disease symptoms, and treatments
3. If unsure, say "I recommend consulting a local agricultural expert"
"""

Conclusion

Building AI agents requires:

Tool Design - Clear, well-documented tools
Memory Management - Appropriate memory strategy for your use case
Error Handling - Graceful failure management
User Experience - Streaming and clear feedback

The complete agricultural agent code is available on .

Questions? Reach out on or email me at !

Building a RAG Pipeline with LangChain: From Document Processing to Vector Search

Mon, 15 Jun 2026 00:00:00 +0000

Retrieval-Augmented Generation (RAG) has become the standard approach for building AI applications that need to access specific knowledge bases. This guide walks through building a complete RAG pipeline from scratch using LangChain.

Above: Production RAG Pipeline — Document Ingestion → Embedding → Retrieval → Augmented Generation → Output

What is RAG?

RAG combines the power of large language models with external knowledge retrieval:

User Query → Retrieval → Context + Query → LLM → Answer

This approach solves the core problem of LLMs: they can only answer based on their training data. RAG allows them to access up-to-date, domain-specific, or private information.

Document Processing

The first step is preparing your documents for retrieval:

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import TokenTextSplitter

# Load documents
loader = PyPDFLoader("knowledge_base.pdf")
documents = loader.load()

# Split into chunks
text_splitter = TokenTextSplitter(
 chunk_size=500,
 chunk_overlap=50,
 encoding_name="cl100k_base" # OpenAI tokenizer
)

chunks = text_splitter.split_documents(documents)

Key Considerations

Chunk Size - Balance between context and retrieval accuracy
Overlap - Prevent important information from being split across chunks
Metadata - Preserve source information for attribution

Vector Storage

Store embeddings for efficient similarity search:

from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Redis

# Initialize embeddings
embeddings = OpenAIEmbeddings()

# Create vector store
vector_store = Redis.from_documents(
 documents=chunks,
 embedding=embeddings,
 redis_url="redis://localhost:6379",
 index_name="knowledge_base"
)

Choosing a Vector Store

Store	Performance	Features	Best For
Redis	High	Real-time updates	Production
Pinecone	High	Managed service	Enterprise
FAISS	Medium	Local, free	Development
Chroma	Medium	Simple setup	Prototyping

Retrieval Strategies

Implement smart retrieval with LangChain:

from langchain.retrievers import ContextualCompressionRetriever
from langchain.retrievers.document_compressors import LLMChainExtractor

# Basic similarity search
retriever = vector_store.as_retriever(
 search_type="similarity",
 search_kwargs={"k": 5}
)

# Advanced: Contextual compression
compressor = LLMChainExtractor.from_llm(llm)
compression_retriever = ContextualCompressionRetriever(
 base_compressor=compressor,
 base_retriever=retriever
)

Hallucination Prevention

Critical for production RAG systems:

from langchain.prompts import ChatPromptTemplate

system_prompt = """You are an agricultural expert. Answer questions based ONLY on the provided context. If the context doesn't contain enough information, say "I don't have enough information to answer this question."

Context: {context}
"""

prompt = ChatPromptTemplate.from_messages([
 ("system", system_prompt),
 ("human", "{input}")
])

Three-Layer Prevention

Retrieval Filtering - Only pass high-relevance documents
Prompt Engineering - Force model to cite sources
Output Validation - Verify responses against source data

Streaming Interface

Implement real-time responses with FastAPI:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio

app = FastAPI()

@app.post("/chat")
async def chat(query: str):
 async def generate():
 async for chunk in chain.astream({"input": query}):
 yield f"data: {chunk.content}\n\n"
 await asyncio.sleep(0.01) # Simulate typing
 yield "data: [DONE]\n\n"

 return StreamingResponse(
 generate(),
 media_type="text/event-stream"
 )

Production Considerations

1. Error Handling

try:
 response = await chain.ainvoke({"input": query})
except Exception as e:
 logger.error(f"RAG error: {e}")
 return {"error": "Failed to generate response"}

2. Caching

from langchain.cache import RedisCache

cache = RedisCache(redis_url="redis://localhost:6379")
llm = OpenAI(cache=cache)

3. Monitoring

Track key metrics:

Retrieval accuracy
Response latency
User satisfaction
Hallucination rate

Conclusion

Building a production RAG system requires attention to:

Document Quality - Good preprocessing is crucial
Retrieval Strategy - Balance precision and recall
Hallucination Prevention - Multi-layered approach
User Experience - Streaming and error handling

The complete code is available on .

Questions? Reach out on or email me at !

LangChain | 1byteone - Java Backend / AI Application Developer

LangChain Core Architecture: Runnables, Models, and Composable Chains

Core mental model

Key mechanics

Python example

Course focus

Engineering practice

Common mistakes

Production checklist

Practice

Hands-on exercise

Conclusion

LangChain Memory: Designing Controlled Multi-Turn State

Core mental model

Key mechanics

Python example

Course focus

Engineering practice

Common mistakes

Production checklist

Practice

Hands-on exercise

Conclusion

LangChain Prompt Chains: Treat Prompts as Maintainable Programs

Core mental model

Key mechanics

Python example

Course focus

Engineering practice

Common mistakes

Production checklist

Practice

Hands-on exercise

Conclusion

LangChain Tool-Calling Agents: Separate Decisions from Execution

Core mental model

Key mechanics

Python example

Course focus

Engineering practice

Common mistakes

Production checklist

Practice

Hands-on exercise

Conclusion

Building AI Agents with LangChain: Tool Integration and Multi-Turn Conversations

Table of Contents

What are AI Agents?

LangChain Agent Framework

Custom Tool Development

Tool Best Practices

Memory Management

Memory Types

Multi-turn Conversations

Production Deployment

1. FastAPI Integration

2. Streaming Responses

3. Error Handling

Real-World Example: Agricultural Q&A Agent

Conclusion

Building a RAG Pipeline with LangChain: From Document Processing to Vector Search

Table of Contents

What is RAG?

Document Processing

Key Considerations

Vector Storage

Choosing a Vector Store

Retrieval Strategies

Hallucination Prevention

Three-Layer Prevention

Streaming Interface

Production Considerations

1. Error Handling

2. Caching

3. Monitoring

Conclusion