*A step-by-step guide to creating your first AI agent using Just247Pipes’ visual pipeline components.*
Introduction
Building AI agents used to mean writing hundreds of lines of orchestration code — managing prompts, routing LLM calls, handling memory, connecting tools, and adding safety rails. Just247Pipes changes all of that. With its drag-and-drop pipeline editor, you can assemble a fully functional AI agent from pre-built components in minutes.
In this article, we’ll build a simple conversational AI agent that can:
– ✅ Chat with users using a large language model
– ✅ Remember conversation history across sessions
– ✅ Call external tools (calculator, web search, etc.)
– ✅ Guard against unsafe content on inputs and outputs
The best part? Zero code. Just connect the pipes.
What is Just247Pipes?
Just247Pipes is a visual pipeline framework for building AI workflows. Instead of writing glue code, you connect components — each with clearly defined input ports, output ports, and configurable properties. Data flows between components through these ports, just like pipes in a plumbing system.
Every component in Just247Pipes follows the same schema:
You configure the properties, connect the ports, and the pipeline runs.
Our Simple AI Agent Architecture
Here’s the architecture we’re building — a conversational agent with memory, tool use, and safety guardrails:
Data Flow
1. User Input enters the pipeline
2. Content Guard (Input) filters and validates the input for safety
3. Plan & Execute Agent orchestrates the reasoning process
4. LLM Router handles model selection and API calls
5. Memory Store persists conversation context
6. Tool Registry executes external tools when needed
7. Content Guard (Output) filters the response for safety
8. User Output delivers the final response
Step 1: The Pipeline Skeleton
Every Just247Pipes pipeline starts with a JSON configuration. Here’s our skeleton:
{
"pipeline": {
"name": "simple-ai-agent",
"version": "1.0",
"description": "A simple conversational AI agent with memory, tools, and guardrails",
"components": [],
"connections": []
}
}We’ll fill in the components and connections as we build each part.
Step 2: Add the LLM Router
| Property | Type | Default | Description |
| llm_provider | select | openai | LLM provider (openai, anthropic, google, local) |
| model_name | string | gpt-4o-mini | Model to use |
| temperature | number | 0.7 | Response creativity (0.0–2.0) |
| max_tokens | integer | 2048 | Maximum response tokens |
| enable_streaming | boolean | true | Stream responses token-by-token |
| timeout_seconds | integer | 60 | Request timeout |
Input/Output Ports
LLM Router
INPUTS: prompt (string) ➜ The prompt to send to the LLM
context (object) ➜ Additional context
model_override (string) ➜ Override default model
OUTPUTS: response (string) ➜ LLM response text
usage (object) ➜ Token usage statistics
model_used (string) ➜ Which model was used
Configuration
{
"type": "router",
"name": "LLM Router",
"properties": {
"llm_provider": "openai",
"model_name": "gpt-4o-mini",
"temperature": 0.7,
"max_tokens": 2048,
"enable_streaming": true,
"timeout_seconds": 60,
"enable_fallback": true,
"fallback_model": "gpt-3.5-turbo",
"enable_retry": true,
"max_retries": 3
}
}Step 3: Add the Plan & Execute Agent
The Plan & Execute Agent is the orchestrator. It receives a task, creates a structured plan, then executes it step-by-step — calling tools and the LLM as needed.
Component Schema
| Property | Type | Default | Description |
| prompt_source | select | auto | Auto-generate prompts or use custom |
| plan_iterations | integer | 3 | Max plan revision cycles |
| max_steps | integer | 20 | Maximum execution steps |
| max_retries | integer | 3 | Retries per step |
| llm_model | string | gpt-4o-mini | LLM for planning/execution |
| memory_type | select | conversation | Memory strategy (buffer, conversation, vector) |
| enable_tools | boolean | false | Enable tool calling |
| max_tool_iterations | integer | 3 | Max tool loops per step |
| verbose | boolean | false | Detailed logging |
Input/Output Ports
Plan & Execute Agent
INPUTS: task (string) ➜ Task description to solve
context (object) ➜ Execution context & prior knowledge
tools (array) ➜ Available tools for execution
tools_filter (string) ➜ Filter tools by tag
OUTPUTS: plan (object) ➜ Generated execution plan (JSON)
current_step (object) ➜ Status of current step
final_result (object) ➜ Final task result
state (object) ➜ Full execution state (persistent)
tools_used (array) ➜ Tools that were executed
tool_steps (array) ➜ Tool execution steps
Configuration
{
"type": "plan_execute_agent",
"name": "Plan & Execute Agent",
"properties": {
"prompt_source": "auto",
"plan_iterations": 3,
"max_steps": 20,
"max_retries": 3,
"llm_model": "gpt-4o-mini",
"memory_type": "conversation",
"enable_tools": true,
"max_tool_iterations": 3,
"require_specific_format": false,
"output_parser": "structured",
"verbose": false
}
}Step 4: Add the Memory Store
The Memory Store gives your agent persistence — it remembers previous conversations and can retrieve relevant context using semantic search.
Component Schema
| Property | Type | Default | Description |
| memory_type | select | sqlite | Storage backend (sqlite, redis, postgresql, mongodb, filesystem, memory) |
| enable_conversation_history | boolean | true | Store conversation history |
| enable_semantic_search | boolean | true | Enable semantic/vector search |
| embedding_model | select | text-embedding-ada-002 | Model for embeddings |
| enable_vector_search | boolean | true | Vector similarity search |
| similarity_threshold | number | 0.7 | Minimum similarity score |
| retention_days | integer | 30 | How long to keep entries |
Input/Output Ports
Memory Store
INPUTS: write (object) ➜ Data to write to memory
read_query (object) ➜ Query to retrieve data
delete_query (object) ➜ Query to delete data
OUTPUTS: read (object) ➜ Data retrieved from memory
write_status (string) ➜ Write operation status
memory_stats (object) ➜ Memory usage statistics
Configuration
{
"type": "memory",
"name": "Memory Store",
"properties": {
"memory_type": "sqlite",
"storage_path": "./memory/",
"enable_conversation_history": true,
"max_conversation_length": 1000,
"enable_semantic_search": true,
"embedding_model": "text-embedding-ada-002",
"enable_vector_search": true,
"similarity_threshold": 0.7,
"retention_days": 30,
"enable_memory_caching": true,
"cache_size_mb": 256,
"enable_memory_pruning": true,
"pruning_strategy": "lru"
}
}Step 5: Add the Tool Registry
The Tool Registry lets your agent execute actions — from simple calculators to web searches and custom API calls.
Component Schema
| Property | Type | Default | Description |
| tool_registry_type | select | builtin | Registry type (builtin, mcp, custom, openapi) |
| enable_builtin_tools | boolean | true | Include built-in tools |
| builtin_tools | array | `[calculator, text_processor, date_time, file_reader, web_search] | Built-in tools to enable |
| enable_tool_caching | boolean | true | Cache identical tool results |
| enable_tool_chaining | boolean | true | Allow chaining multiple tools |
| max_chain_length | integer | 5 | Max tools in a chain |
| enable_tool_parallelism | boolean | true | Execute tools in parallel |
| max_concurrent_tools | integer | 5 | Max tools running simultaneously |
Input/Output Ports
Tool Registry
INPUTS: tool_request (object) ➜ Tool execution request with function name and parameters
context (object) ➜ Additional context for execution
OUTPUTS: tool_result (object) ➜ Result from tool execution
tool_status (string) ➜ Execution status (success/error/timeout)
available_tools (array) ➜ List of available tools
Configuration
{
"type": "tool",
"name": "Tool Registry",
"properties": {
"tool_registry_type": "builtin",
"enable_builtin_tools": true,
"builtin_tools": [
"calculator",
"text_processor",
"date_time",
"file_reader",
"web_search"
],
"enable_tool_caching": true,
"cache_ttl_seconds": 300,
"enable_tool_chaining": true,
"max_chain_length": 5,
"enable_tool_parallelism": true,
"max_concurrent_tools": 5,
"enable_tool_permissions": true,
"enable_fallback_tools": true,
"retry_failed_tools": true,
"max_retries": 3
}
}Step 6: Add Content Guardrails
The Content Guard protects your agent — filtering unsafe content on both input and output. We’ll use two instances: one for input and one for output.
Component Schema
| Property | Type | Default | Description |
| guard_mode | select | filter | Guard mode (filter, block, warn, log_only) |
| enable_profanity_filter | boolean | true | Filter offensive language |
| enable_toxicity_detection | boolean | true | Detect toxic content |
| toxicity_threshold | number | 0.7 | Minimum score to flag content |
| enable_pii_detection | boolean | true | Detect & protect personal info |
| pii_action | select | mask | Action on PII (mask, remove, redact, flag) |
| enable_length_limits | boolean | true | Enforce content length |
| max_length | integer | 10000 | Maximum content length |
Input/Output Ports
Content Guard
INPUTS: content_in (any) ➜ Content to be filtered and validated
context (object) ➜ Additional context for evaluation
OUTPUTS: filtered_out (any) ➜ Filtered and safe content output
guard_status (object) ➜ Guard evaluation status and details
violations (array) ➜ List of detected violations
Configuration — Input Guard
{
"type": "guardrail",
"name": "Input Guard",
"properties": {
"guard_mode": "block",
"enable_profanity_filter": true,
"enable_toxicity_detection": true,
"toxicity_threshold": 0.7,
"enable_pii_detection": true,
"pii_action": "mask",
"pii_types": ["email", "phone", "ssn", "credit_card", "address"],
"enable_content_classification": true,
"blocked_categories": ["hate_speech", "self_harm"],
"enable_length_limits": true,
"max_length": 5000,
"enable_context_awareness": true,
"context_window_size": 10
}
}Configuration — Output Guard
{
"type": "guardrail",
"name": "Output Guard",
"properties": {
"guard_mode": "filter",
"enable_profanity_filter": true,
"enable_toxicity_detection": true,
"toxicity_threshold": 0.5,
"enable_pii_detection": true,
"pii_action": "redact",
"enable_content_classification": true,
"blocked_categories": ["hate_speech", "self_harm", "violence"],
"enable_fact_checking": false,
"enable_guard_logging": true,
"log_violations": true
}
}Step 7: Complete Pipeline — Wiring It All Together
Now let’s connect everything. Here’s the complete pipeline JSON:
{
"pipeline": {
"name": "simple-ai-agent",
"version": "1.0",
"description": "A simple conversational AI agent with memory, tools, and guardrails",
"components": [
{
"id": "input_guard",
"type": "guardrail",
"name": "Input Guard",
"properties": {
"guard_mode": "block",
"enable_profanity_filter": true,
"enable_toxicity_detection": true,
"toxicity_threshold": 0.7,
"enable_pii_detection": true,
"pii_action": "mask",
"pii_types": ["email", "phone", "ssn", "credit_card", "address"],
"blocked_categories": ["hate_speech", "self_harm"],
"enable_length_limits": true,
"max_length": 5000,
"enable_context_awareness": true
}
},
{
"id": "agent",
"type": "plan_execute_agent",
"name": "Plan & Execute Agent",
"properties": {
"prompt_source": "auto",
"plan_iterations": 3,
"max_steps": 20,
"max_retries": 3,
"llm_model": "gpt-4o-mini",
"memory_type": "conversation",
"enable_tools": true,
"max_tool_iterations": 3,
"output_parser": "structured"
}
},
{
"id": "llm_router",
"type": "router",
"name": "LLM Router",
"properties": {
"llm_provider": "openai",
"model_name": "gpt-4o-mini",
"temperature": 0.7,
"max_tokens": 2048,
"enable_streaming": true,
"enable_fallback": true,
"fallback_model": "gpt-3.5-turbo"
}
},
{
"id": "memory",
"type": "memory",
"name": "Memory Store",
"properties": {
"memory_type": "sqlite",
"enable_conversation_history": true,
"enable_semantic_search": true,
"embedding_model": "text-embedding-ada-002",
"similarity_threshold": 0.7,
"retention_days": 30
}
},
{
"id": "tools",
"type": "tool",
"name": "Tool Registry",
"properties": {
"tool_registry_type": "builtin",
"enable_builtin_tools": true,
"builtin_tools": ["calculator", "text_processor", "date_time", "web_search"],
"enable_tool_caching": true,
"enable_tool_chaining": true,
"max_chain_length": 5,
"enable_tool_parallelism": true,
"max_concurrent_tools": 5
}
},
{
"id": "output_guard",
"type": "guardrail",
"name": "Output Guard",
"properties": {
"guard_mode": "filter",
"enable_profanity_filter": true,
"enable_toxicity_detection": true,
"toxicity_threshold": 0.5,
"enable_pii_detection": true,
"pii_action": "redact",
"blocked_categories": ["hate_speech", "self_harm", "violence"],
"enable_guard_logging": true,
"log_violations": true
}
}
],
"connections": [
{
"from": { "component": "input_guard", "port": "filtered_out" },
"to": { "component": "agent", "port": "task" }
},
{
"from": { "component": "input_guard", "port": "guard_status" },
"to": { "component": "agent", "port": "context" }
},
{
"from": { "component": "agent", "port": "final_result" },
"to": { "component": "output_guard", "port": "content_in" }
},
{
"from": { "component": "memory", "port": "read" },
"to": { "component": "agent", "port": "context" }
},
{
"from": { "component": "agent", "port": "state" },
"to": { "component": "memory", "port": "write" }
},
{
"from": { "component": "tools", "port": "available_tools" },
"to": { "component": "agent", "port": "tools" }
},
{
"from": { "component": "agent", "port": "tool_steps" },
"to": { "component": "tools", "port": "tool_request" }
},
{
"from": { "component": "agent", "port": "current_step" },
"to": { "component": "llm_router", "port": "prompt" }
},
{
"from": { "component": "llm_router", "port": "response" },
"to": { "component": "agent", "port": "initial_state" }
}
]
}
}How It Works: End-to-End Walkthrough
Let’s trace a user message through the pipeline:
Example: “What’s 15% of 2,340?”
Step 1 ─ INPUT GUARD
────────────────────
User input: “What’s 15% of 2,340?”
✅ No violations detected
✅ No PII found
→ Passes through filtered_out port
Step 2 ─ MEMORY STORE (Read)
────────────────────
Query: Search for prior context with this user
→ Returns: [] (first conversation)
Step 3 ─ PLAN & EXECUTE AGENT
────────────────────
Task: “What’s 15% of 2,340?”
Context: {conversation_history: []}
Agent creates a plan:
┌────────────────────────────────┐
│ Plan: │
│ 1. Use calculator tool │
│ to compute 15% of 2340 │
│ 2. Return result to user │
└────────────────────────────────┘
Step 4 ─ TOOL REGISTRY
────────────────────
Tool request: calculator.multiply(0.15, 2340)
→ Result: 351
Step 5 ─ LLM ROUTER
────────────────────
Prompt: “Formulate a natural response for: 15% of 2,340 = 351”
Model: gpt-4o-mini
→ Response: “15% of 2,340 is 351.”
Step 6 ─ OUTPUT GUARD
────────────────────
Content: “15% of 2,340 is 351.”
✅ No violations
✅ No PII leakage
→ Passes through filtered_out port
Step 7 ─ MEMORY STORE (Write)
────────────────────
Writes: {role: “assistant”, content: “15% of 2,340 is 351.”}
Step 8 ─ USER OUTPUT
────────────────────
Final response: “15% of 2,340 is 351.”
Component Reference
Here’s a quick-reference table of all the components used in our agent:
| Component | Type | Category | Purpose |
| Input Guard | guardrail | agent-services | Filters unsafe user input |
| Output Guard | guardrail | agent-services | Filters unsafe AI output |
| Plan & Execute Agent | plan_execute_agent | processing | Orchestrates reasoning & tool use |
| LLM Router | router | processing | Routes to language models |
| Memory Store | memory | agent-services | Persists conversation & context |
| Tool Registry | tool | agent-services | Executes external tools |
Customization Ideas
Once you have the basic agent running, try these enhancements:
🔧 Add MCP Tools
Replace the builtin tool registry with MCP (Model Context Protocol) for external tool servers:
{
"tool_registry_type": "mcp",
"mcp_server_url": "https://your-mcp-server.com",
"mcp_api_key": "${MCP_API_KEY}",
"mcp_timeout": 10000
}🔧 Use Vector Memory
Switch from SQLite to a vector database for semantic memory retrieval:
{
"memory_type": "redis",
"enable_semantic_search": true,
"enable_vector_search": true,
"embedding_model": "text-embedding-3-small",
"vector_dimension": 1536,
"connection_string": "${REDIS_URL}"
}🔧 Add Custom Guard Rules
Add your own content filtering rules:
{
"enable_custom_rules": true,
"custom_rules": "{\"block_competitors\": [\"BrandX\", \"BrandY\"], \"require_disclaimer\": true}"
}🔧 Upgrade the LLM
Switch to a more powerful model for complex tasks:
{
"llm_provider": "openai",
"model_name": "gpt-4o",
"temperature": 0.3,
"max_tokens": 4096
}🔧 Add Fallback Models
Ensure reliability with automatic model fallbacks:
{
"enable_fallback": true,
"fallback_model": "gpt-4o-mini",
"enable_retry": true,
"max_retries": 3,
"retry_delay_ms": 1000
}Key Properties at a Glance
LLM Router — Most Important Settings
| Property | Default | Recommended | Notes |
| model_name | gpt-4o-mini | gpt-4o-mini for simple tasks | Use gpt-4o for complex reasoning |
| temperature | 0.7 | 0.3–0.7 | Lower = more deterministic |
| max_tokens | 2048 | 2048 | Increase for long responses |
| enable_streaming | true | true | Better UX with streaming |
| enable_fallback | true | true | Always enable for reliability |
Content Guard — Most Important Settings
| Property | Default | Recommended | Notes |
| guard_mode | filter | block for input, filter for output | Block dangerous input, filter output |
| toxicity_threshold | 0.7 | 0.7 | Lower = more strict |
| pii_action | mask | mask for input, redact for output | Protects user privacy |
| enable_pii_detection | true | true | Essential for production |
| blocked_categories | hate_speech, self_harm | hate_speech, self_harm, violence | Add categories as needed |
Tool Registry — Most Important Settings
| Property | Default | Recommended | Notes |
| tool_registry_type | builtin | builtin for start | Switch to mcp for custom tools |
| builtin_tools | 5 tools | Start with calculator + web_search | Add more as needed |
| enable_tool_chaining | true | true | Lets agent chain tool calls |
| enable_tool_parallelism | true | true | Faster execution |
| max_concurrent_tools | 5 | 5 | Increase for I/O-heavy agents |
Troubleshooting
| Problem | Likely Cause | Solution |
| Agent doesn’t call tools | enable_tools is false | Set to `true` in Plan & Execute Agent |
| No conversation memory | Memory not connected | Connect memory.read → agent.context |
| Unsafe output slips through | Output guard too lenient | Lower toxicity_threshold to 0.5 |
| Tool timeouts | Default timeout too low | Increase timeout_ms in Tool Registry |
| Agent loops infinitely | No step limit | Set max_steps in Plan & Execute Agent |
| High latency | Synchronous tool calls | Enable enable_tool_parallelism |
Conclusion
Just247Pipes makes building AI agents as simple as connecting pipes. With just 6 components and 9 connections, we built a production-ready agent that:
– 🧠 Thinks with Plan & Execute reasoning
– 💬 Remembers with persistent Memory Store
– 🔨 Acts with built-in Tool Registry
– 🛡️ Protects with dual Content Guards
– ⚡ Scales with configurable LLM routing
The entire pipeline is defined in a single JSON file — no code, no frameworks, no boilerplate. Just pipes.
Ready to build your own agent?
Report an issue
Leave a Reply