Building and Orchestrating Tools¶
A comprehensive guide to building custom AI tools and orchestrating multiple tools within AI Agents. This note explains how tools are created, registered, selected, chained, and coordinated to solve complex tasks. It also covers LangChain tools, toolkits, ReAct agents, agent executors, enterprise orchestration patterns, and production best practices.
Part 1 — Building AI Tools¶
1. Overview¶
Artificial Intelligence Agents become truly useful when they can interact with the external world.
A Large Language Model (LLM) is an excellent reasoning engine, capable of understanding natural language, generating text, summarizing documents, writing code, and answering questions. However, on its own, it cannot perform actions outside its training environment.
For example, a standalone LLM cannot:
- Search the latest news on the internet
- Query a SQL database
- Execute Python code
- Send emails
- Access enterprise applications
- Book meetings
- Retrieve customer records
- Update business systems
To perform these tasks, AI Agents rely on Tools.
A tool provides a controlled interface between the LLM and an external capability, allowing the agent to retrieve information or execute actions.
However, real-world business problems rarely require a single tool.
Consider the following request:
Generate last month's sales report,
create visualizations,
email the report to management,
and archive a copy in SharePoint.
A single tool cannot complete this workflow.
Instead, an AI Agent orchestrates multiple tools.
This coordinated execution of multiple tools is called Tool Orchestration.
It transforms AI Agents from simple assistants into intelligent workflow automation systems capable of solving complex enterprise problems.
2. Why AI Agents Need Tools¶
Although Large Language Models possess remarkable reasoning capabilities, they cannot directly interact with the external world.
Their knowledge is limited to:
- Training data
- Current conversation
- Context supplied in prompts
Without tools, an LLM cannot:
- Retrieve live information
- Access enterprise databases
- Perform exact calculations
- Execute business workflows
- Interact with APIs
- Update applications
Example:
Without tools:
With tools:
Tools bridge the gap between language understanding and real-world execution.
3. What is an AI Tool?¶
An AI Tool is an external capability that an AI Agent can invoke to retrieve information or perform actions.
Instead of solving every task internally, the LLM delegates specialized work to tools.
Examples include:
- Calculator
- Weather API
- Search Engine
- SQL Database
- Vector Database
- Python Interpreter
- Email Service
- Calendar
- CRM System
- ERP Platform
Conceptually:
Each tool specializes in performing a specific operation more accurately or efficiently than the language model alone.
4. Types of AI Tools¶
Enterprise AI Agents commonly work with different categories of tools.
Information Retrieval Tools¶
Retrieve information from external knowledge sources.
Examples:
- Search engines
- Enterprise Search
- Knowledge Bases
- Vector Databases
- RAG Systems
Computation Tools¶
Perform mathematical or analytical operations.
Examples:
- Calculator
- Python Interpreter
- Statistical Libraries
Database Tools¶
Retrieve structured business information.
Examples:
- SQL Database
- PostgreSQL
- MongoDB
- Data Warehouse
Communication Tools¶
Enable interaction with users and systems.
Examples:
- Slack
- Microsoft Teams
- SMS
- Calendar
File Processing Tools¶
Work with enterprise documents.
Examples:
- PDF Reader
- Excel Processing
- OCR
- CSV Processing
Enterprise Integration Tools¶
Connect AI Agents with business applications.
Examples:
- Salesforce
- SAP
- ServiceNow
- Jira
- Workday
Each category extends the capabilities of AI Agents in different ways.
5. Building Custom Tools¶
While frameworks such as LangChain provide many built-in tools, organizations often require custom tools tailored to their business needs.
Examples include:
- Retrieve customer profile
- Check inventory
- Generate invoice
- Submit expense report
- Create support ticket
Building a custom tool typically involves:
For example:
Good custom tools should:
- Perform one specific task
- Be reusable
- Return structured outputs
- Handle errors gracefully
Custom tools are the foundation of enterprise AI automation.
6. Tool Registration¶
Before an AI Agent can use a tool, the tool must be registered.
Registration informs the agent:
- The tool exists
- What it does
- What parameters it accepts
- What it returns
Workflow:
Registered tools become available during reasoning.
Example registry:
The agent cannot use tools that are not registered.
7. Tool Metadata¶
Metadata provides additional information that helps the LLM understand when and how to use a tool.
Typical metadata includes:
- Name
- Description
- Parameters
- Return Type
- Required Inputs
- Usage Guidelines
Example:
Description:
Input:
Output:
High-quality metadata significantly improves tool selection accuracy.
8. Tool Descriptions¶
Among all metadata fields, the description is the most important.
The LLM relies heavily on descriptions to decide whether a tool is appropriate.
Poor description:
Better description:
Well-written descriptions should explain:
- Purpose
- Inputs
- Outputs
- Appropriate use cases
- Limitations
Descriptive tools reduce incorrect tool selection.
9. Tool Inputs and Outputs¶
Every tool accepts structured inputs and produces structured outputs.
Example:
Another example:
Well-designed tools should:
- Validate inputs
- Return predictable outputs
- Use structured formats (typically JSON)
- Report errors clearly
Consistent input and output design enables reliable orchestration of multiple tools.
10. LangChain Tools¶
LangChain provides a standardized abstraction for integrating tools with AI Agents.
Instead of manually connecting every API or function, developers wrap external capabilities as LangChain Tools.
Examples include:
- Python REPL
- SQL Database Tool
- Search Tool
- Calculator
- File Tools
- Web Browser Tools
Architecture:
Benefits include:
- Standard interface
- Easy integration
- Reusability
- Framework compatibility
- Simplified orchestration
LangChain Tools form the foundation of many production AI Agent implementations.
11. Toolkits¶
A Toolkit is a collection of related tools grouped together to solve a particular category of problems.
Instead of registering individual tools one by one, developers can expose an entire toolkit.
Examples:
Another example:
Advantages include:
- Better organization
- Easier maintenance
- Reusable tool collections
- Simplified development
Toolkits are widely used in enterprise AI applications.
12. Enterprise Use Cases¶
Building custom tools enables AI Agents to automate a wide variety of enterprise workflows.
Customer Support¶
- Retrieve customer records
- Search knowledge bases
- Create support tickets
Software Engineering¶
- Execute code
- Analyze repositories
- Search documentation
- Generate deployment reports
Business Intelligence¶
- Query databases
- Generate dashboards
- Produce analytics reports
IT Operations¶
- Monitor infrastructure
- Analyze logs
- Restart services
- Investigate incidents
Human Resources¶
- Retrieve employee policies
- Process leave requests
- Schedule interviews
Finance¶
- Generate invoices
- Calculate financial metrics
- Validate transactions
- Produce compliance reports
Enterprise AI Assistants¶
Combine multiple tools such as:
- RAG
- SQL Databases
- CRM Systems
- Python
- Search APIs
to automate complex business workflows.
As enterprise AI adoption accelerates, custom tools and well-designed toolkits have become the building blocks of intelligent AI Agents, enabling them to interact with diverse systems, automate end-to-end processes, and deliver reliable, production-ready solutions across modern organizations.
Part 2 — Tool Orchestration¶
13. What is Tool Orchestration?¶
Building a single tool is only the first step in creating an intelligent AI Agent.
Real-world business problems often require multiple tools working together in a coordinated manner.
The process of selecting, invoking, coordinating, and managing multiple tools to accomplish a goal is known as Tool Orchestration.
Instead of calling one tool, an AI Agent intelligently decides:
- Which tool to use
- When to use it
- In what order
- Whether multiple tools are required
- Whether another tool should be called based on previous results
Example:
The agent may execute:
Multiple tools collaborate to complete a single business task.
Tool orchestration transforms independent tools into an intelligent workflow.
14. Agent Executor¶
The Agent Executor is the component responsible for coordinating tool execution.
Think of it as the "workflow manager" of an AI Agent.
Its responsibilities include:
- Receiving the user's request
- Asking the LLM to reason
- Selecting the appropriate tool
- Executing the tool
- Returning observations to the LLM
- Repeating the process until the goal is achieved
Architecture:
User Request
│
▼
Large Language Model
│
▼
Agent Executor
│
┌────┼────┐
▼ ▼ ▼
Tool Tool Tool
A B C
│
▼
Observations
│
▼
Large Language Model
│
▼
Final Response
The Agent Executor enables iterative reasoning and execution, allowing AI Agents to solve complex, multi-step tasks.
15. Tool Selection¶
One of the most important responsibilities of an AI Agent is choosing the correct tool.
Consider the request:
Available tools:
The LLM reasons:
Another example:
Available tools:
The selected tool becomes:
Tool selection depends on:
- User intent
- Tool descriptions
- Required inputs
- Previous reasoning
- Available tools
Good tool descriptions improve selection accuracy.
16. ReAct Pattern¶
One of the most influential AI Agent architectures is ReAct (Reason + Act).
Instead of immediately answering a question, the agent repeatedly reasons, performs an action, observes the result, and reasons again.
Workflow:
Example:
The agent reasons:
Then:
Advantages of ReAct:
- Better reasoning
- More accurate answers
- Reduced hallucinations
- Supports complex workflows
Many modern AI Agent frameworks are based on the ReAct paradigm.
17. create_react_agent()¶
LangChain provides a helper for building ReAct-based AI Agents called:
This function combines:
- Large Language Model
- Prompt Template
- Tool Collection
- Agent Executor
Conceptually:
The resulting agent automatically:
- Chooses tools
- Executes tools
- Observes results
- Continues reasoning
- Produces a final answer
This significantly reduces the amount of custom orchestration code developers need to write.
18. Tool Chaining¶
Many enterprise tasks require sequential execution of tools.
The output from one tool becomes the input for another.
Example:
Another example:
Benefits:
- Modular workflows
- Reusable components
- Better maintainability
- Easier debugging
Tool chaining is one of the most common orchestration patterns in AI applications.
19. Multi-Step Workflows¶
Enterprise processes often consist of several dependent tasks.
Example:
Workflow:
Characteristics of multi-step workflows:
- Sequential execution
- Intermediate reasoning
- Dependency between tasks
- Multiple tool invocations
AI Agents can dynamically adjust these workflows depending on intermediate results.
20. Parallel Tool Execution¶
Not every task requires sequential execution.
Independent tasks can be executed simultaneously.
Example:
Architecture:
User Request
│
▼
Agent Executor
│
┌───────────┴───────────┐
▼ ▼
Weather Tool Traffic Tool
│ │
└───────────┬───────────┘
▼
Combined Response
Benefits include:
- Lower latency
- Faster execution
- Improved scalability
- Better resource utilization
Many enterprise orchestration engines support parallel execution for independent tasks.
21. Monitoring Tool Execution¶
Production AI systems must monitor tool usage continuously.
Key metrics include:
Tool Success Rate¶
How often tools complete successfully.
Response Time¶
Average execution latency.
Error Rate¶
Percentage of failed tool invocations.
Token Usage¶
LLM token consumption before and after tool execution.
API Cost¶
Cost incurred from external APIs.
Tool Frequency¶
Most frequently used tools.
Monitoring enables teams to:
- Detect failures
- Improve performance
- Reduce costs
- Optimize workflows
Observability is essential for production AI systems.
💻 LangChain Tool Orchestration Walkthrough¶
The following example demonstrates how a production AI Agent is built by progressively adding custom tools, registering them with the agent, enabling ReAct reasoning, and orchestrating tool execution. Each layer has a single responsibility, reflecting the modular architecture used in enterprise AI systems.
Step 1 — Build Custom Tools¶
Create reusable Python functions that encapsulate individual business capabilities.
from langchain_core.tools import tool
@tool
def search_customer(customer_id: str) -> str:
"""Retrieve customer information using customer ID."""
return f"Customer {customer_id}: Gold Member"
@tool
def generate_invoice(customer_id: str) -> str:
"""Generate an invoice for a customer."""
return f"Invoice generated for {customer_id}"
@tool
def send_email(message: str) -> str:
"""Send an email notification."""
return "Email sent successfully"
Step 2 — Register Available Tools¶
Expose the tools so the AI Agent can discover and invoke them during reasoning.
Step 3 — Configure the Language Model¶
Initialize the Large Language Model responsible for reasoning and tool selection.
from langchain_ibm import ChatWatsonx
llm = ChatWatsonx(
model_id="ibm/granite-4-h-small",
project_id="your-project-id",
url="https://us-south.ml.cloud.ibm.com"
)
Step 4 — Create the ReAct Agent¶
Combine the LLM with the registered tools to enable reasoning and action.
Step 5 — Create the Agent Executor¶
The Agent Executor manages reasoning, tool invocation, observations, and final response generation.
from langchain.agents import AgentExecutor
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True
)
Step 6 — Execute a Multi-Step Request¶
The agent automatically determines which tools to invoke, executes them in sequence, and generates the final response.
response = agent_executor.invoke({
"input": """
Retrieve customer CUST-1024,
generate an invoice,
and email the confirmation.
"""
})
print(response["output"])
End-to-End Orchestration Flow¶
User Request
│
▼
Large Language Model
│
▼
ReAct Reasoning Loop
│
▼
Agent Executor
│
┌──────────────┼──────────────┐
▼ ▼ ▼
Customer Tool Invoice Tool Email Tool
│ │ │
└──────────────┼──────────────┘
▼
Tool Observations
│
▼
Large Language Model
│
▼
Final AI Response
This simplified workflow demonstrates how enterprise AI Agents extend Large Language Models with reusable tools, coordinate them through an Agent Executor, and apply ReAct reasoning to solve complex multi-step tasks. By separating tool implementation, registration, reasoning, and execution into independent layers, the architecture becomes more modular, maintainable, scalable, and suitable for production AI applications.
22. Best Practices¶
Successful tool orchestration requires thoughtful engineering.
Build Small Tools¶
Each tool should have one responsibility.
Prefer Reusable Components¶
Avoid duplicating business logic across tools.
Chain Tools Logically¶
Ensure outputs naturally become inputs for subsequent tools.
Avoid Unnecessary Tool Calls¶
Only invoke tools that add value.
Design for Failure¶
Every workflow should anticipate:
- API failures
- Network issues
- Invalid inputs
- Service outages
Monitor Continuously¶
Track:
- Success rates
- Latency
- Costs
- User satisfaction
- Tool utilization
Secure Tool Access¶
Protect enterprise systems through:
- Authentication
- Authorization
- Encryption
- Audit logs
Build Modular Workflows¶
Instead of one large workflow, compose smaller reusable orchestration blocks.
Well-designed tool orchestration enables AI Agents to coordinate multiple capabilities efficiently, automate complex enterprise workflows, and adapt dynamically to changing conditions. Combined with robust monitoring, modular design, and secure integrations, tool orchestration forms the operational backbone of production-ready AI Agent systems and prepares the foundation for advanced LangChain agents, LCEL pipelines, and enterprise AI architectures.
Part 3 — Enterprise Perspective¶
23. Common Mistakes¶
Building custom tools is relatively straightforward. Building reliable, production-grade tool orchestration systems is significantly more challenging.
Many AI Agent failures are caused not by the Large Language Model itself, but by poor tool design and orchestration strategies.
Below are some of the most common mistakes.
Building Monolithic Tools¶
Many developers create one large tool responsible for multiple unrelated tasks.
Example:
Problems include:
- Difficult maintenance
- Poor reusability
- Higher complexity
- Increased debugging effort
Instead, create focused tools.
Small, reusable tools lead to better orchestration.
Poor Tool Descriptions¶
The Large Language Model relies heavily on tool descriptions when deciding which tool to invoke.
Poor description:
Better description:
A clear description should explain:
- Purpose
- Inputs
- Outputs
- Appropriate usage
- Limitations
Better descriptions improve tool selection accuracy.
Overloading the Agent with Too Many Tools¶
Providing dozens or hundreds of tools to an AI Agent can reduce decision quality.
Example:
Problems include:
- Slower reasoning
- Incorrect tool selection
- Increased token usage
- Higher costs
Instead:
Expose only the tools required for the current workflow.
Poor Tool Chaining¶
Tool chains should have a logical flow.
Poor workflow:
Better workflow:
Each tool should naturally build upon the output of the previous step.
Ignoring Intermediate Validation¶
Many workflows assume every tool succeeds.
Instead, validate intermediate outputs.
Example:
The workflow should:
rather than continuing with invalid data.
Ignoring Tool Failures¶
External systems can fail because of:
- Network issues
- Authentication failures
- API limits
- Service outages
- Invalid inputs
Production AI Agents should support:
Robust orchestration anticipates failures rather than assuming success.
Hardcoding Workflow Logic¶
Business workflows evolve continuously.
Avoid embedding rigid execution sequences directly into application code.
Instead:
- Use modular orchestration
- Compose reusable workflows
- Separate business logic from orchestration logic
This simplifies maintenance and future enhancements.
Ignoring Observability¶
Without monitoring, identifying orchestration issues becomes difficult.
Monitor:
- Tool execution time
- Success rate
- Failure rate
- Token usage
- API cost
- Workflow completion rate
Observability is a key requirement for enterprise AI systems.
24. Interview Questions¶
Beginner¶
- What is an AI Tool?
- Why do AI Agents need tools?
- What is Tool Orchestration?
- What is a Toolkit?
- What is the Agent Executor?
- What is the ReAct pattern?
Intermediate¶
- Explain Tool Chaining.
- How does an AI Agent select tools?
- What is the role of
create_react_agent()? - What is the difference between sequential and parallel tool execution?
- How would you build reusable tools?
- Why are tool descriptions important?
Advanced¶
- Design an enterprise Tool Orchestration architecture.
- How would you monitor tool execution?
- How would you optimize orchestration latency?
- How would you secure enterprise tools?
- Compare Tool Chaining with workflow orchestration engines.
- How would you scale AI Agent orchestration across multiple services?
25. 🚀 Quick Revision Sheet¶
Tool Development Workflow¶
Tool Orchestration¶
User Request
↓
Large Language Model
↓
Agent Executor
↓
Tool Selection
↓
Tool Execution
↓
Observation
↓
Reason
↓
Final Response
ReAct Pattern¶
Tool Chaining¶
Parallel Execution¶
User Request
│
┌─────────┴─────────┐
▼ ▼
Tool A Tool B
│ │
└─────────┬─────────┘
▼
Combined Response
LangChain Components¶
- Tool
- Toolkit
- Agent Executor
- ReAct Agent
create_react_agent()- Large Language Model
- Prompt Template
Enterprise Tool Categories¶
- Search APIs
- SQL Databases
- Vector Databases
- Python Execution
- CRM Systems
- ERP Platforms
- File Processing
- Email Services
- Calendar Systems
Best Practices¶
- Build one tool for one responsibility.
- Write descriptive tool metadata.
- Register only relevant tools.
- Prefer reusable toolkits.
- Validate intermediate outputs.
- Handle failures gracefully.
- Monitor orchestration continuously.
- Secure enterprise integrations.
Remember¶
Building tools enables AI Agents to access external capabilities, while Tool Orchestration enables them to coordinate multiple tools into intelligent workflows. Frameworks such as LangChain provide abstractions like Tools, Toolkits, Agent Executors, and ReAct Agents that simplify the development of modular, reusable, and production-ready AI systems capable of solving complex enterprise tasks through dynamic reasoning and coordinated execution.
26. Key Takeaways¶
- AI Tools extend the capabilities of Large Language Models by providing controlled access to external systems such as APIs, databases, Python interpreters, search engines, and enterprise applications.
- Custom tools encapsulate business logic into reusable components that AI Agents can invoke through Tool Calling.
- Tool Registration and well-defined metadata enable AI Agents to discover, understand, and correctly select the appropriate tools during reasoning.
- Tool Orchestration coordinates multiple tools to execute complex, multi-step workflows, allowing AI Agents to automate sophisticated business processes.
- LangChain simplifies orchestration through abstractions such as Tools, Toolkits, Agent Executors, and ReAct Agents, reducing the complexity of building production AI applications.
- Enterprise AI systems benefit from Tool Chaining, Parallel Execution, robust monitoring, error handling, and modular workflow design, improving scalability, reliability, and maintainability.
- Effective tool orchestration transforms AI Agents from conversational assistants into intelligent workflow engines capable of reasoning, executing actions, adapting to observations, and integrating seamlessly with enterprise ecosystems.
27. References¶
Course¶
- IBM RAG & Agentic AI Professional Certificate
- Module: Fundamentals of Building AI Agents
Documentation¶
- LangChain Tools Documentation
- LangChain Agents Documentation
- LangChain Toolkits Documentation
- LangGraph Documentation
- ReAct: Synergizing Reasoning and Acting in Language Models (Research Paper)
- IBM watsonx.ai Documentation
Hands-on Resources¶
- 01-AI-Math-Assistant-With-Langchain-Tool-Calling
- 02-AI-Powered-Data-Analysis-With-LCEL
- 03-Build-Interactive-LLM-Agents-With-Tools
Repository Placement¶
Repository
└── ibm-rag-and-agentic-ai-journey
└── notes
└── ai-agents
├── 01-ai-agent-fundamentals.md
├── 02-tool-calling-and-function-calling.md
├── 03-building-and-orchestrating-tools.md
├── 04-lcel-and-manual-tool-calling.md
├── 05-langchain-built-in-agents.md
├── 06-ai-agent-design-best-practices.md
└── 07-enterprise-ai-agent-architecture.md
🎯 Foundation for AI Tool Orchestration¶
This note expands on Tool Calling by demonstrating how AI Agents can build sophisticated workflows through coordinated tool execution.
The learning progression continues as follows:
- AI Agent Fundamentals — Core concepts, architecture, reasoning, and lifecycle.
- Tool Calling and Function Calling — Learn how AI Agents discover and invoke external tools.
- Building and Orchestrating Tools (this note) — Design reusable tools and coordinate them into intelligent workflows using Agent Executors and ReAct patterns.
- LCEL and Manual Tool Calling — Build modular AI pipelines using LangChain Expression Language and explicit tool invocation.
- LangChain Built-in Agents — Explore ready-made agent implementations such as DataFrame Agents and SQL Agents.
- AI Agent Design Best Practices — Apply production engineering principles, security, observability, and reliability.
- Enterprise AI Agent Architecture — Integrate tools, memory, RAG, governance, and monitoring into scalable enterprise AI systems.
Together, these notes provide a structured journey from creating individual tools to orchestrating enterprise-grade AI workflows, laying the groundwork for advanced topics such as LangGraph, Agentic AI, and Multi-Agent Systems.
Diagrams to Include¶
Custom Tool Workflow¶
Tool Orchestration¶
User Request
│
▼
Large Language Model
│
▼
Agent Executor
│
┌──────┼────────┐
▼ ▼ ▼
Tool A Tool B Tool C
│ │ │
└──────┼────────┘
▼
Combined Result
│
▼
Final Response
ReAct Agent¶
Enterprise AI Agent¶
AI Agent
│
┌─────────────┼──────────────┐
▼ ▼ ▼
Search API SQL Tool Python Tool
▼ ▼ ▼
Vector DB CRM System Analytics API
│ │ │
└─────────────┼──────────────┘
▼
Business Response
Repository Placement¶
notes/
generative-ai/
rag/
ai-agents/
├── 01-ai-agent-fundamentals.md
├── 02-tool-calling-and-function-calling.md
├── 03-building-and-orchestrating-tools.md
├── 04-lcel-and-manual-tool-calling.md
├── 05-langchain-built-in-agents.md
├── 06-ai-agent-design-best-practices.md
└── 07-enterprise-ai-agent-architecture.md
agentic-ai/
Relationship with Previous Notes¶
| Previous Learning | This Note Builds Upon |
|---|---|
| AI Agent Fundamentals | Agent architecture and lifecycle |
| Tool Calling and Function Calling | Tool invocation concepts |
| LangChain | Tool abstractions |
| Python | Building custom tools |
| APIs | External integrations |
| RAG | Retrieval tools used by AI agents |
Purpose of This Note¶
The previous note introduced Tool Calling and explained how AI Agents invoke external capabilities.
This note goes one step further by explaining how tools are built and orchestrated.
Real-world AI Agents rarely use a single tool.
Instead, they coordinate multiple tools such as:
- Search engines
- Databases
- Vector stores
- Python interpreters
- REST APIs
- Email services
- Calendar systems
- Business applications
You'll learn how to design reusable tools, expose them to Large Language Models, chain multiple tools together, implement ReAct-style reasoning, and orchestrate complex workflows using LangChain.
These concepts form the bridge between simple AI assistants and production-ready enterprise AI Agents capable of solving sophisticated business problems.
Learning Outcomes¶
After completing this note, you will be able to:
- Build reusable custom tools for AI Agents.
- Understand LangChain Tool abstractions and Toolkits.
- Design effective tool metadata and descriptions.
- Orchestrate multiple tools within a single workflow.
- Explain the ReAct reasoning pattern and Agent Executor.
- Build multi-step tool-driven AI applications.
- Apply enterprise best practices for scalable and reliable tool orchestration.
- Prepare for advanced topics such as LCEL, LangChain Agents, and Enterprise AI Agent Architecture.
Enterprise AI Engineering Handbook
Building Production-Grade Enterprise AI Systems — One Chapter at a Time.