Langroid Patterns

Instructions

Below is an INDEX of design patterns organized by category. Each item describes WHAT you might want to implement, followed by a REFERENCE to a document with a complete code example.

Scan this index to find patterns matching your needs, then consult the corresponding document.

Agent & Task Basics

Task Returns Tool Directly

Create a Langroid Agent equipped with a single Tool (a ToolMessage), and wrap it in a Task so that running the task returns that ToolMessage directly. Use this pattern when you want a simple LLM agent that returns a structured response.
- Reference:
```
./task-return-tool.md
```

Tool Handlers

Stateful Handler on Agent
Define a STATEFUL tool handler as a METHOD on the agent (not inside the ToolMessage). Use this pattern when: (a) the tool handler needs to execute external operations (API calls, database queries, file I/O), (b) you need to track state across retries (e.g., failure counter), (c) the handler needs access to agent-level resources (connections, configs), or (d) you want Langroid to automatically loop errors back to the LLM for self-correction. The method name must match the
```
request
```
field of the ToolMessage. Return a string for errors (LLM sees it and can retry), or DoneTool(content=result) to terminate successfully.
- Reference:
```
./agent-tool-handler-with-state.md
```
Handler with Validation
Validate tool output against agent state before accepting it. Use this pattern when: (a) the LLM's tool output must preserve certain content from the input (e.g., placeholders, required fields), (b) you want automatic retry if validation fails, (c) you need to compare tool output against context the LLM received. Define a handler method on a custom agent class that stores the input context as state, validates the tool output, and returns an error string for retry or AgentDoneTool for success (note: use AgentDoneTool, NOT DoneTool). Use
```
done_sequences=["T[ToolName], A"]
```
so the handler runs before task termination.
- Reference:
```
./agent-handler-validation-with-state.md
```

Task Control

Terminate on Specific Tool
Terminate a Task only when a SPECIFIC tool is called. Use
```
TaskConfig(done_sequences=["T[ToolName]"])
```
to exit immediately when that tool is emitted, or
```
TaskConfig(done_sequences=["T[ToolName], A"])
```
to exit after the tool is emitted AND handled by the agent. Use this when an agent has multiple tools but you only want one specific tool to trigger task termination.
- Reference:
```
./done-sequences-specific-tool.md
```
Batch Processing
Run the SAME task on MULTIPLE inputs concurrently using
```
run_batch_tasks()
```
. Use this pattern when: (a) you need to process many items with the same agent/task logic, (b) you want parallelism without manual asyncio/threading, (c) you need state isolation between items (each gets a cloned agent with fresh message history), (d) you want to avoid connection exhaustion from creating too many agents manually. Each item gets a cloned task+agent, runs independently, results collected in order. Supports batch_size for concurrency limiting.
- Reference:
```
./run-batch-tasks.md
```

Integration & Output

MCP Tools Integration
Enable a Langroid agent to use MCP (Model Context Protocol) tools from an external MCP server like Claude Code. Use this pattern when: (a) you want your agent to use file editing tools (Read, Edit, Write) from Claude Code, (b) you need to connect to any MCP server via stdio transport, (c) you want to enable ALL tools from an MCP server or just SPECIFIC tools selectively, (d) you want to customize/post-process MCP tool results before returning to the LLM. Uses
```
@mcp_tool
```
decorator for specific tools or
```
get_tools_async()
```
for all tools.
- Reference:
```
./mcp-tool-integration.md
```
Quiet Mode
Suppress verbose Langroid agent output (streaming, tool JSON, intermediate messages) while showing your own custom progress messages. Use this pattern when: (a) you want clean CLI output showing only milestone events, (b) you're running a multi-step workflow and want to show progress without agent noise, (c) you need thread-safe output control. Use
```
quiet_mode()
```
context manager to wrap agent task.run() calls, then print your own messages outside the context.
- Reference:
```
./quiet-mode.md
```

patterns

NPX Install

Tags

SKILL.md Content