Patterns

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

1. 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

2. 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

3. 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

4. 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

5. 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

6. 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

7. 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