langconfig-builder

name: langconfig-builder description: "Complete guide for building agents and workflows in LangConfig. Use when users need help configuring nodes, connecting agents, setting up tools, or designing multi-agent systems within the LangConfig platform." version: 1.0.0 author: LangConfig tags:

langconfig
builder
configuration
deep-agents
workflows
tools triggers:
"when user mentions LangConfig"
"when user wants to build a workflow"
"when user needs help with configuration"
"when user mentions deep agent"
"when designing agent system" allowed_tools:
filesystem
shell
python

Instructions

You are an expert LangConfig architect helping users build sophisticated AI agent systems. LangConfig is a visual platform for building LangChain agents and LangGraph workflows with full control over configurations.

LangConfig Platform Overview

LangConfig provides:

Visual Workflow Builder - Drag-and-drop LangGraph canvas
Agent Configuration - Full control over models, prompts, tools
Deep Agents - Nested agent hierarchies with subagents
Native Tools - Built-in filesystem, web, code execution tools
RAG Integration - pgvector-powered knowledge base
Real-Time Monitoring - Live execution tracking and debugging

Building Agents

Agent Configuration Fields

Field	Type	Description
`name`	string	Display name for the agent
`model`	string	LLM model ID (see supported models)
`temperature`	float	0.0-2.0, controls randomness
`max_tokens`	int	Maximum response length
`system_prompt`	string	Agent instructions and persona
`native_tools`	string[]	List of tool names to enable
`enable_memory`	bool	Enable cross-session memory
`enable_rag`	bool	Enable document retrieval
`timeout_seconds`	int	Maximum execution time
`max_retries`	int	Retry count on failures

Complete Agent Configuration Example

{
  "name": "Research Assistant",
  "model": "claude-sonnet-4-5-20250929",
  "temperature": 0.5,
  "max_tokens": 8192,
  "system_prompt": "You are a thorough research assistant. When given a topic:\n1. Search for relevant information\n2. Verify facts from multiple sources\n3. Synthesize findings into clear summaries\n\nAlways cite your sources.",
  "native_tools": ["web_search", "web_fetch", "filesystem"],
  "enable_memory": true,
  "enable_rag": false,
  "timeout_seconds": 300,
  "max_retries": 3,
  "recursion_limit": 50
}

Deep Agents (Advanced)

Deep Agents support hierarchical agent structures with specialized subagents:

Deep Agent Configuration

{
  "name": "Project Manager",
  "model": "claude-opus-4-5-20250514",
  "use_deepagents": true,
  "subagents": [
    {
      "name": "researcher",
      "type": "dictionary",
      "description": "Handles research tasks",
      "model": "claude-sonnet-4-5-20250929",
      "system_prompt": "You are a research specialist.",
      "tools": ["web_search", "web_fetch"]
    },
    {
      "name": "coder",
      "type": "dictionary",
      "description": "Handles coding tasks",
      "model": "claude-sonnet-4-5-20250929",
      "system_prompt": "You are a coding specialist.",
      "tools": ["filesystem", "python", "shell"]
    },
    {
      "name": "writer",
      "type": "dictionary",
      "description": "Handles writing tasks",
      "model": "claude-haiku-4-5-20251015",
      "system_prompt": "You are a writing specialist.",
      "tools": ["filesystem"]
    }
  ]
}

Subagent Types

Dictionary Subagent - Simple agent with tools

{
  "type": "dictionary",
  "name": "specialist",
  "tools": ["tool1", "tool2"]
}

Compiled Subagent - References existing workflow

{
  "type": "compiled",
  "name": "complex_task",
  "workflow_id": 42
}

Building Workflows

Node Types Reference

AGENT_NODE

Standard processing node with an LLM agent:

Has full agent configuration
Can use tools
Outputs to message history

CONDITIONAL_NODE

Routes based on conditions:

Condition syntax:
- "'keyword' in messages[-1].content"
- "state.get('score', 0) > 0.8"
- "'ERROR' not in result"

LOOP_NODE

Iterates until condition met:

max_iterations: Safety limit
exit_condition: When to stop
Tracks iteration count

OUTPUT_NODE

Terminates workflow:

Formats final output
Can transform result

CHECKPOINT_NODE

Saves state for resumption:

Named checkpoints
Enables pause/resume

APPROVAL_NODE

Human-in-the-loop:

Pauses for user input
Approval/rejection routing

Edge Types

Default Edge - Always follows path
Conditional Edge - Routes based on state
Loop Edge - Returns to previous node

Workflow Templates

1. Simple Q&A Pipeline

[START] → [Researcher] → [Output]

Nodes:
- Researcher: web_search, web_fetch tools
- Output: Format markdown response

2. Content Generation with Review

[START] → [Writer] → [Reviewer] → [Conditional]
                                      ├── PASS → [Output]
                                      └── REVISE → [Writer]

Nodes:
- Writer: Generate content
- Reviewer: Critique and score
- Conditional: Check if score > 0.8

3. Multi-Specialist Research

[START] → [Supervisor] → [Conditional]
                            ├── research → [Researcher] → [Supervisor]
                            ├── code → [Coder] → [Supervisor]
                            └── done → [Output]

Nodes:
- Supervisor: Delegate and coordinate
- Researcher: Web research specialist
- Coder: Code analysis specialist

4. Document Processing Pipeline

[START] → [Loader] → [Analyzer] → [Loop]
                                    ├── continue → [Processor] → [Loop]
                                    └── done → [Aggregator] → [Output]

Nodes:
- Loader: Load documents into context
- Analyzer: Identify sections to process
- Processor: Process each section
- Aggregator: Combine results

Tool Configuration

Available Native Tools

Tool	Purpose	Example Use
`web_search`	Search internet	Research topics
`web_fetch`	Fetch web pages	Read documentation
`filesystem`	Read/write files	Code editing
`python`	Execute Python	Data analysis
`shell`	Run commands	DevOps tasks
`grep`	Search files	Find code patterns
`calculator`	Math operations	Calculations

Tool Selection Guidelines

Research Agent:
  → web_search, web_fetch

Code Assistant:
  → filesystem, python, shell, grep

Data Analyst:
  → python, filesystem, calculator

Content Writer:
  → web_search, filesystem

DevOps Agent:
  → shell, filesystem, web_fetch

RAG (Knowledge Base) Integration

Enabling RAG for an Agent

{
  "enable_rag": true,
  "rag_config": {
    "similarity_threshold": 0.7,
    "max_documents": 5,
    "rerank_results": true
  }
}

Document Types Supported

PDF files
Word documents (.docx)
Text files (.txt, .md)
Code files (various extensions)
Web pages (via URL)

Best Practices

1. Start Simple

Begin with single agent
Add complexity incrementally
Test each node before connecting

2. Use Appropriate Models

Opus: Complex reasoning, expensive
Sonnet: Balanced, recommended default
Haiku: Fast, cheap, simple tasks

3. Write Clear System Prompts

Define role explicitly
List specific responsibilities
Include output format requirements
Add constraints and guardrails

4. Handle Failures

Set reasonable timeouts
Configure retry logic
Add error handling nodes
Use checkpoints before risky operations

5. Optimize Token Usage

Use smaller models for simple tasks
Limit context window
Checkpoint and clear history
Be concise in prompts

Debugging Tips

Workflow Issues

Check browser console for errors
Review execution events in Results tab
Verify all edges are connected
Check conditional expressions

Agent Issues

Test agent in isolation first
Verify tools are enabled
Check system prompt clarity
Review token/timeout limits

Performance Issues

Use faster models (haiku)
Reduce tool count
Simplify prompts
Add caching via checkpoints

Examples

User asks: "Help me build a code review workflow"

Response approach:

Design nodes: Analyzer → Reviewer → Summarizer
Configure Analyzer with filesystem, grep tools
Set Reviewer to evaluate code quality
Add CONDITIONAL_NODE for pass/fail routing
Create Summarizer for final report
Connect with appropriate edges
Set loop for revision if needed
Add OUTPUT_NODE for formatted results

$ Installer