langchain-core-workflow-a
Build LangChain chains and prompts for structured LLM workflows.Use when creating prompt templates, building LCEL chains,or implementing sequential processing pipelines.Trigger with phrases like "langchain chains", "langchain prompts","LCEL workflow", "langchain pipeline", "prompt template".
When & Why to Use This Skill
This Claude skill enables developers to architect and deploy structured LLM workflows using LangChain Expression Language (LCEL). It streamlines the creation of reusable prompt templates, sequential processing pipelines, and complex branching logic, providing a production-ready framework for building sophisticated AI-driven applications with consistent output parsing and type-safe data flow.
Use Cases
- Case 1: Building multi-stage content pipelines that first extract key data points and then generate summaries or translations based on those points.
- Case 2: Creating modular chat-style prompt templates with system messages and placeholders for dynamic conversation history management.
- Case 3: Implementing parallel processing workflows to execute multiple LLM tasks simultaneously, such as performing sentiment analysis and keyword extraction on the same input.
- Case 4: Developing conditional routing logic (branching) to direct user queries to different specialized chains based on the intent or type of the input.
| name | langchain-core-workflow-a |
|---|---|
| description | | |
| allowed-tools | Read, Write, Edit |
| version | 1.0.0 |
| license | MIT |
| author | Jeremy Longshore <jeremy@intentsolutions.io> |
LangChain Core Workflow A: Chains & Prompts
Overview
Build production-ready chains using LangChain Expression Language (LCEL) with prompt templates, output parsers, and composition patterns.
Prerequisites
- Completed
langchain-install-authsetup - Understanding of prompt engineering basics
- Familiarity with Python type hints
Instructions
Step 1: Create Prompt Templates
from langchain_core.prompts import (
ChatPromptTemplate,
SystemMessagePromptTemplate,
HumanMessagePromptTemplate,
MessagesPlaceholder
)
# Simple template
simple_prompt = ChatPromptTemplate.from_template(
"Translate '{text}' to {language}"
)
# Chat-style template
chat_prompt = ChatPromptTemplate.from_messages([
SystemMessagePromptTemplate.from_template(
"You are a {role}. Respond in {style} style."
),
MessagesPlaceholder(variable_name="history", optional=True),
HumanMessagePromptTemplate.from_template("{input}")
])
Step 2: Build LCEL Chains
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
llm = ChatOpenAI(model="gpt-4o-mini")
# Basic chain: prompt -> llm -> parser
basic_chain = simple_prompt | llm | StrOutputParser()
# Invoke the chain
result = basic_chain.invoke({
"text": "Hello, world!",
"language": "Spanish"
})
print(result) # "Hola, mundo!"
Step 3: Chain Composition
from langchain_core.runnables import RunnablePassthrough, RunnableParallel
# Sequential chain
chain1 = prompt1 | llm | StrOutputParser()
chain2 = prompt2 | llm | StrOutputParser()
sequential = chain1 | (lambda x: {"summary": x}) | chain2
# Parallel execution
parallel = RunnableParallel(
summary=prompt1 | llm | StrOutputParser(),
keywords=prompt2 | llm | StrOutputParser(),
sentiment=prompt3 | llm | StrOutputParser()
)
results = parallel.invoke({"text": "Your input text"})
# Returns: {"summary": "...", "keywords": "...", "sentiment": "..."}
Step 4: Branching Logic
from langchain_core.runnables import RunnableBranch
# Conditional branching
branch = RunnableBranch(
(lambda x: x["type"] == "question", question_chain),
(lambda x: x["type"] == "command", command_chain),
default_chain # Fallback
)
result = branch.invoke({"type": "question", "input": "What is AI?"})
Output
- Reusable prompt templates with variable substitution
- Type-safe LCEL chains with clear data flow
- Composable chain patterns (sequential, parallel, branching)
- Consistent output parsing
Examples
Multi-Step Processing Chain
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
llm = ChatOpenAI(model="gpt-4o-mini")
# Step 1: Extract key points
extract_prompt = ChatPromptTemplate.from_template(
"Extract 3 key points from: {text}"
)
# Step 2: Summarize
summarize_prompt = ChatPromptTemplate.from_template(
"Create a one-sentence summary from these points: {points}"
)
# Compose the chain
chain = (
{"points": extract_prompt | llm | StrOutputParser()}
| summarize_prompt
| llm
| StrOutputParser()
)
summary = chain.invoke({"text": "Long article text here..."})
With Context Injection
from langchain_core.runnables import RunnablePassthrough
def get_context(input_dict):
"""Fetch relevant context from database."""
return f"Context for: {input_dict['query']}"
chain = (
RunnablePassthrough.assign(context=get_context)
| prompt
| llm
| StrOutputParser()
)
result = chain.invoke({"query": "user question"})
Error Handling
| Error | Cause | Solution |
|---|---|---|
| Missing Variable | Template variable not provided | Check input dict keys match template |
| Type Error | Wrong input type | Ensure inputs match expected schema |
| Parse Error | Output doesn't match parser | Use more specific prompts or fallback |
Resources
Next Steps
Proceed to langchain-core-workflow-b for agents and tools workflow.