Add Skill: langgraph-agent-workflow

Extracted from: https://github.com/pipeshub-ai/pipeshub-ai.git
Score: 1.0

skills/langgraph-agent-workflow/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: langgraph-agent-workflow
+version: 1.0.0
+description: Orchestrate multi-step AI agents using LangGraph with SerperDevTool for
+  RAG, code execution, and citation generation
+inputs:
+- LangGraph chain configuration files defining agent workflows
+- SerperDevTool integration for LLM tool access
+- React agent creation scripts via create_react_agent
+- Knowledge graph retrieval and citation generation pipelines
+steps:
+- 'Step 1: Define LangGraph chain architecture with SerperDevTool integration - Create
+  a LangGraph chain that combines retrieval, reasoning, and response generation using
+  SerperDevTool for tool access'
+- 'Step 2: Implement React agent wrapper - Use create_react_agent to build a frontend
+  agent that can interact with the LangGraph chain'
+- 'Step 3: Configure RAG pipeline - Set up vector search (Qdrant/OpenSearch) and knowledge
+  graph retrieval (Neo4j/ArangoDB) with citation generation'
+- 'Step 4: Add code execution sandbox - Integrate artifact generation capabilities
+  for code-related tasks'
+- "Step 5: Orchestrate multi-step research workflow - Chain search \u2192 deep research\
+  \ \u2192 agent response in a single LangGraph workflow"
+outputs:
+- Reusable LangGraph chain definition (pyfile) with configurable steps
+- React agent frontend component that can be deployed independently
+- RAG pipeline that generates block citations and grounded answers
+- Code execution sandbox for artifact generation
+- Documentation for parameterizing workflows for different tasks
+tags: []
+metadata:
+  source_repo: https://github.com/pipeshub-ai/pipeshub-ai.git
+  extracted_at: ''
+  confidence: 0.95
+---
+
+# langgraph-agent-workflow
+
+Orchestrate multi-step AI agents using LangGraph with SerperDevTool for RAG, code execution, and citation generation
+
+## Setup
+
+**Dependencies:**
+
+```text
+pip install langgraph>=0.7.0 serper-dev-tool>=0.1.0 qdrant-client or opensearch-dsl neo4j-driver or arango-database-driver react, next.js
+```
+
+**Setup steps:**
+
+1. Install LangGraph and SerperDevTool dependencies
+1. Configure vector store (Qdrant/OpenSearch) and knowledge graph (Neo4j/ArangoDB)
+1. Define chain topology with retrieval, reasoning, and response steps
+1. Build React agent frontend using create_react_agent
+1. Test multi-step agent workflows end-to-end
+
+## Key Files
+
+- `pipeshub-ai/workflows/agent_chain.py - Main LangGraph chain definition`
+- `pipeshub-ai/workflows/agent_react.py - React agent wrapper`
+- `pipeshub-ai/workflows/rag_pipeline.py - RAG with citation generation`
+- `pipeshub-ai/workflows/code_sandbox.py - Code execution sandbox`
+
+## Steps
+
+1. Step 1: Define LangGraph chain architecture with SerperDevTool integration - Create a LangGraph chain that combines retrieval, reasoning, and response generation using SerperDevTool for tool access
+2. Step 2: Implement React agent wrapper - Use create_react_agent to build a frontend agent that can interact with the LangGraph chain
+3. Step 3: Configure RAG pipeline - Set up vector search (Qdrant/OpenSearch) and knowledge graph retrieval (Neo4j/ArangoDB) with citation generation
+4. Step 4: Add code execution sandbox - Integrate artifact generation capabilities for code-related tasks
+5. Step 5: Orchestrate multi-step research workflow - Chain search → deep research → agent response in a single LangGraph workflow
+
+## Implementation Details
+
+```python
+chain = LangGraph()
+```
+
+```python
+chain.add_step(SerperDevToolAgent())
+```
+
+```python
+agent = create_react_agent(chain, SerperDevToolAgent())
+```
+
+```python
+workflow = chain.start()
+```
+
+## Inputs
+
+- LangGraph chain configuration files defining agent workflows
+- SerperDevTool integration for LLM tool access
+- React agent creation scripts via create_react_agent
+- Knowledge graph retrieval and citation generation pipelines
+
+## Outputs
+
+- Reusable LangGraph chain definition (pyfile) with configurable steps
+- React agent frontend component that can be deployed independently
+- RAG pipeline that generates block citations and grounded answers
+- Code execution sandbox for artifact generation
+- Documentation for parameterizing workflows for different tasks
+
+## Failure Modes
+
+- GraphDB connection failures if Neo4j/ArangoDB is not properly configured
+- Vector store unavailability (Qdrant/OpenSearch) causing RAG pipeline to fail
+- LLM tool access errors if SerperDevTool is not properly initialized
+- Agent timeout if complex multi-step reasoning exceeds time limits
+- Sandbox execution failures if code has security vulnerabilities or infinite loops
+
+## Source
+
+Extracted from: [https://github.com/pipeshub-ai/pipeshub-ai.git](https://github.com/pipeshub-ai/pipeshub-ai.git)
+Confidence: 0.95

skills/langgraph-agent-workflow/commands.md

@@ -0,0 +1,6 @@
+# Commands: langgraph-agent-workflow
+
+## Available Commands
+
+- `/skill langgraph-agent-workflow` — Load this skill
+- `/run langgraph-agent-workflow` — Execute workflow

skills/langgraph-agent-workflow/examples.md

@@ -0,0 +1,10 @@
+# Examples: langgraph-agent-workflow
+
+## Usage Example
+
+```python
+# How to use this skill
+# Inputs: LangGraph chain configuration files defining agent workflows, SerperDevTool integration for LLM tool access, React agent creation scripts via create_react_agent, Knowledge graph retrieval and citation generation pipelines
+# Process: Step 1: Define LangGraph chain architecture with SerperDevTool integration - Create a LangGraph chain that combines retrieval, reasoning, and response generation using SerperDevTool for tool access → Step 2: Implement React agent wrapper - Use create_react_agent to build a frontend agent that can interact with the LangGraph chain → Step 3: Configure RAG pipeline - Set up vector search (Qdrant/OpenSearch) and knowledge graph retrieval (Neo4j/ArangoDB) with citation generation
+# Outputs: Reusable LangGraph chain definition (pyfile) with configurable steps, React agent frontend component that can be deployed independently, RAG pipeline that generates block citations and grounded answers, Code execution sandbox for artifact generation, Documentation for parameterizing workflows for different tasks
+```

skills/langgraph-agent-workflow/metadata.json

@@ -0,0 +1,36 @@
+{
+  "name": "langgraph-agent-workflow",
+  "version": "1.0.0",
+  "goal": "Orchestrate multi-step AI agents using LangGraph with SerperDevTool for RAG, code execution, and citation generation",
+  "inputs": [
+    "LangGraph chain configuration files defining agent workflows",
+    "SerperDevTool integration for LLM tool access",
+    "React agent creation scripts via create_react_agent",
+    "Knowledge graph retrieval and citation generation pipelines"
+  ],
+  "steps": [
+    "Step 1: Define LangGraph chain architecture with SerperDevTool integration - Create a LangGraph chain that combines retrieval, reasoning, and response generation using SerperDevTool for tool access",
+    "Step 2: Implement React agent wrapper - Use create_react_agent to build a frontend agent that can interact with the LangGraph chain",
+    "Step 3: Configure RAG pipeline - Set up vector search (Qdrant/OpenSearch) and knowledge graph retrieval (Neo4j/ArangoDB) with citation generation",
+    "Step 4: Add code execution sandbox - Integrate artifact generation capabilities for code-related tasks",
+    "Step 5: Orchestrate multi-step research workflow - Chain search \u2192 deep research \u2192 agent response in a single LangGraph workflow"
+  ],
+  "outputs": [
+    "Reusable LangGraph chain definition (pyfile) with configurable steps",
+    "React agent frontend component that can be deployed independently",
+    "RAG pipeline that generates block citations and grounded answers",
+    "Code execution sandbox for artifact generation",
+    "Documentation for parameterizing workflows for different tasks"
+  ],
+  "failure_modes": [
+    "GraphDB connection failures if Neo4j/ArangoDB is not properly configured",
+    "Vector store unavailability (Qdrant/OpenSearch) causing RAG pipeline to fail",
+    "LLM tool access errors if SerperDevTool is not properly initialized",
+    "Agent timeout if complex multi-step reasoning exceeds time limits",
+    "Sandbox execution failures if code has security vulnerabilities or infinite loops"
+  ],
+  "confidence": 0.95,
+  "explanation": "PipesHub provides a reusable LangGraph-based agent workflow framework that can be parameterized for different tasks. The core pattern involves defining a LangGraph chain with SerperDevTool integration for tool access, creating a React agent wrapper, and configuring RAG pipelines with citation generation. This framework can be reused across RAG, code execution, and research workflows by adjusting the chain definition and agent configuration.",
+  "source_repo": "https://github.com/pipeshub-ai/pipeshub-ai.git",
+  "score": 1.0
+}

skills/langgraph-agent-workflow/tests.md

@@ -1,4 +1,4 @@
-# Tests: langgraph-multi-agent-router
+# Tests: langgraph-agent-workflow
 
 ## Test Checklist
 

skills/langgraph-multi-agent-router/SKILL.md

@@ -1,96 +0,0 @@
----
-name: langgraph-multi-agent-router
-version: 1.0.0
-description: Orchestrate a multi-agent workflow where specialized agents collaborate
-  sequentially to gather information, structure it, and generate a final response
-inputs:
-- User query string (e.g., destination location)
-- BedrockModel configuration (model_id, temperature, top_p)
-- Pre-configured agents with specific system prompts and tool sets
-steps:
-- Researcher agent executes with system prompt to gather raw destination facts (places,
-  history, accommodations, food, web pages) using BedrockModel and available tools
-  (calculator, current_time)
-- Travel guide agent receives raw research output and structures it into labeled sections
-  (Must-See Attractions, Historical Highlights, Accommodation Areas, Culinary Delights,
-  Suggested Web Pages)
-- Writer agent receives the structured guide and synthesizes it into a professional
-  client-facing response with clear formatting and emphasis on the suggested web pages
-outputs:
-- Raw research data (JSON string containing gathered facts)
-- Structured guide content (markdown-formatted travel guide with labeled sections)
-- Final client response (professional formatted response ready for delivery)
-tags: []
-metadata:
-  source_repo: https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git
-  extracted_at: ''
-  confidence: 0.95
----
-
-# langgraph-multi-agent-router
-
-Orchestrate a multi-agent workflow where specialized agents collaborate sequentially to gather information, structure it, and generate a final response
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install langchain langgraph bedrock-model pydantic
-```
-
-**Setup steps:**
-
-1. Install langchain and langgraph packages
-1. Configure BedrockModel with desired parameters (model_id, temperature, top_p)
-1. Create three Agent instances with specific system prompts and tool sets
-1. Initialize LangGraph with the agent chain and run the workflow
-
-## Key Files
-
-- `agents/langchain_langgraph/00-basic-agent/agent.py`
-- `agents/langchain_langgraph/02-agent-with-tools-structured-output/agent.py`
-- `agents/langchain_langgraph/08-langgraph-multi-agents-sequential-pattern/agent.py`
-
-## Steps
-
-1. Researcher agent executes with system prompt to gather raw destination facts (places, history, accommodations, food, web pages) using BedrockModel and available tools (calculator, current_time)
-2. Travel guide agent receives raw research output and structures it into labeled sections (Must-See Attractions, Historical Highlights, Accommodation Areas, Culinary Delights, Suggested Web Pages)
-3. Writer agent receives the structured guide and synthesizes it into a professional client-facing response with clear formatting and emphasis on the suggested web pages
-
-## Implementation Details
-
-```python
-Researcher agent uses BedrockModel with temperature=0.7, top_p=0.9 to gather destination facts
-```
-
-```python
-Travel guide agent receives raw output and formats into 5 labeled sections
-```
-
-```python
-Writer agent takes structured guide and writes professional client response
-```
-
-## Inputs
-
-- User query string (e.g., destination location)
-- BedrockModel configuration (model_id, temperature, top_p)
-- Pre-configured agents with specific system prompts and tool sets
-
-## Outputs
-
-- Raw research data (JSON string containing gathered facts)
-- Structured guide content (markdown-formatted travel guide with labeled sections)
-- Final client response (professional formatted response ready for delivery)
-
-## Failure Modes
-
-- Researcher agent fails to gather sufficient data or returns incomplete results
-- Travel guide agent fails to structure information correctly or produces unreadable output
-- Writer agent fails to format the final response properly or loses key information from the guide
-
-## Source
-
-Extracted from: [https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git](https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git)
-Confidence: 0.95

skills/langgraph-multi-agent-router/commands.md

@@ -1,6 +0,0 @@
-# Commands: langgraph-multi-agent-router
-
-## Available Commands
-
-- `/skill langgraph-multi-agent-router` — Load this skill
-- `/run langgraph-multi-agent-router` — Execute workflow

skills/langgraph-multi-agent-router/examples.md

@@ -1,10 +0,0 @@
-# Examples: langgraph-multi-agent-router
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: User query string (e.g., destination location), BedrockModel configuration (model_id, temperature, top_p), Pre-configured agents with specific system prompts and tool sets
-# Process: Researcher agent executes with system prompt to gather raw destination facts (places, history, accommodations, food, web pages) using BedrockModel and available tools (calculator, current_time) → Travel guide agent receives raw research output and structures it into labeled sections (Must-See Attractions, Historical Highlights, Accommodation Areas, Culinary Delights, Suggested Web Pages) → Writer agent receives the structured guide and synthesizes it into a professional client-facing response with clear formatting and emphasis on the suggested web pages
-# Outputs: Raw research data (JSON string containing gathered facts), Structured guide content (markdown-formatted travel guide with labeled sections), Final client response (professional formatted response ready for delivery)
-```

skills/langgraph-multi-agent-router/metadata.json

@@ -1,29 +0,0 @@
-{
-  "name": "langgraph-multi-agent-router",
-  "version": "1.0.0",
-  "goal": "Orchestrate a multi-agent workflow where specialized agents collaborate sequentially to gather information, structure it, and generate a final response",
-  "inputs": [
-    "User query string (e.g., destination location)",
-    "BedrockModel configuration (model_id, temperature, top_p)",
-    "Pre-configured agents with specific system prompts and tool sets"
-  ],
-  "steps": [
-    "Researcher agent executes with system prompt to gather raw destination facts (places, history, accommodations, food, web pages) using BedrockModel and available tools (calculator, current_time)",
-    "Travel guide agent receives raw research output and structures it into labeled sections (Must-See Attractions, Historical Highlights, Accommodation Areas, Culinary Delights, Suggested Web Pages)",
-    "Writer agent receives the structured guide and synthesizes it into a professional client-facing response with clear formatting and emphasis on the suggested web pages"
-  ],
-  "outputs": [
-    "Raw research data (JSON string containing gathered facts)",
-    "Structured guide content (markdown-formatted travel guide with labeled sections)",
-    "Final client response (professional formatted response ready for delivery)"
-  ],
-  "failure_modes": [
-    "Researcher agent fails to gather sufficient data or returns incomplete results",
-    "Travel guide agent fails to structure information correctly or produces unreadable output",
-    "Writer agent fails to format the final response properly or loses key information from the guide"
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow demonstrates a reusable multi-stage agent pattern where specialized agents collaborate in sequence. The Researcher agent gathers raw information using a domain-specific model, the Travel Guide agent structures that information into a consistent format, and the Writer agent synthesizes the final output. This pattern can be adapted to other domains (e.g., code generation, data analysis, research workflows) by swapping the agent types and system prompts while maintaining the same three-step structure.",
-  "source_repo": "https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git",
-  "score": 1.0
-}