Add Skill: unifai-workflow-execution

Extracted from: https://github.com/redhat-community-ai-tools/UnifAI.git Score: 1.0
2026-08-05 15:14:35 +00:00
77 changed files with 147 additions and 1897 deletions
@@ -16,10 +16,10 @@ llm:
  api_key: ""
  max_tokens: 8000

-# Secondary LLM for pipeline tasks — uses LFM on 3060 (llama.cpp)
+# Secondary LLM for pipeline tasks — uses Ollama on 3060 (non-reasoning model)
 llm_pipeline:
-  base_url: http://100.64.0.4:8080
-  model: C:\models\LFM2.5-2.6B-Q4_K_M.gguf
+  base_url: http://100.64.0.4:11434
+  model: qwen2.5:7b
  api_key: ""
  max_tokens: 6000

@@ -34,8 +34,8 @@ scout:
    - 'rag agent workflow'
    - 'tool calling workflow'
  filters:
-    stars_min: 10
-    pushed_after: 2026-02-01
+    stars_min: 15
+    pushed_after: 2026-05-01
    language: Python
    archived: false
    size_max_kb: 10000
@@ -1,10 +1,10 @@
 """Stage 8: Publisher — Create branch, commit, open PR on Gitea."""
+import json
 import subprocess
 import os
 import tempfile
+import shutil
 import datetime
-import requests
-

 def publish_skill(review_result, config):
    """
@@ -33,113 +33,58 @@ def publish_skill(review_result, config):
    branch_name = f"skill/{skill_name}-{ts}"

    with tempfile.TemporaryDirectory() as tmpdir:
-        repo_dir = os.path.join(tmpdir, "agent-skills")
-
        # Clone repo
+        repo_dir = os.path.join(tmpdir, "agent-skills")
        result = subprocess.run(
-            ["git", "clone", "--branch", "main", "--depth", "1", clone_url, repo_dir],
+            ["git", "clone", "--branch", "main", "--single-branch", clone_url, repo_dir],
            capture_output=True, text=True, timeout=30
        )
        if result.returncode != 0:
+            # Try without --branch (might not exist yet)
            result = subprocess.run(
-                ["git", "clone", "--depth", "1", clone_url, repo_dir],
+                ["git", "clone", clone_url, repo_dir],
                capture_output=True, text=True, timeout=30
            )
            if result.returncode != 0:
-                return {"status": "CLONE_ERROR", "error": result.stderr[:500]}
+                return {
+                    "status": "CLONE_ERROR",
+                    "error": result.stderr[:500],
+                }

        # Configure git
        subprocess.run(["git", "config", "user.email", "hermes@agent.local"], cwd=repo_dir)
        subprocess.run(["git", "config", "user.name", "Hermes Pipeline"], cwd=repo_dir)

-        # Check for duplicates in skills/ directory
-        skills_dir = os.path.join(repo_dir, "skills")
-        existing_skills = []
-        if os.path.isdir(skills_dir):
-            existing_skills = [d for d in os.listdir(skills_dir) if os.path.isdir(os.path.join(skills_dir, d))]
-
-        if skill_name in existing_skills:
-            return {
-                "status": "SKIP",
-                "reason": f"Skill '{skill_name}' already exists in skills/ directory",
-            }
-
        # Create skill directory
        skill_dir = os.path.join(repo_dir, "skills", skill_name)
        os.makedirs(skill_dir, exist_ok=True)

-        # Write skill files
+        # Write files
        for filename, content in files.items():
            filepath = os.path.join(skill_dir, filename)
-            with open(filepath, "w") as f:
+            with open(filepath, 'w') as f:
                f.write(content)

-        # Verify files were written
-        written_files = []
-        for root, dirs, fnames in os.walk(skill_dir):
-            for fn in fnames:
-                written_files.append(os.path.join(root, fn))
-
-        if not written_files:
-            return {"status": "EMPTY_SKILL", "reason": "No files written to skill directory"}
-
-        # Stage and commit
-        add_result = subprocess.run(
-            ["git", "add", "skills/"], cwd=repo_dir, capture_output=True, text=True
+        # Add and commit
+        subprocess.run(["git", "add", "."], cwd=repo_dir, capture_output=True)
+        subprocess.run(
+            ["git", "commit", "-m", f"Add Skill: {skill_name}\n\nExtracted from: {gen.get('metadata', {}).get('source_repo', 'unknown')}\nScore: {gen.get('metadata', {}).get('score', 0)}"],
+            cwd=repo_dir, capture_output=True
        )

-        # Check if there are actually staged changes
-        status_result = subprocess.run(
-            ["git", "diff", "--cached", "--name-only"],
-            cwd=repo_dir, capture_output=True, text=True
-        )
-        staged_files = status_result.stdout.strip().split("\n") if status_result.stdout.strip() else []
-
-        if not staged_files:
-            # Nothing to commit — files might already exist. Force add.
-            subprocess.run(["git", "add", "-f", "skills/"], cwd=repo_dir, capture_output=True, text=True)
-            status_result = subprocess.run(
-                ["git", "diff", "--cached", "--name-only"],
-                cwd=repo_dir, capture_output=True, text=True
-            )
-            staged_files = status_result.stdout.strip().split("\n") if status_result.stdout.strip() else []
-
-        if not staged_files:
-            return {
-                "status": "NO_CHANGES",
-                "reason": f"No new files to commit for {skill_name}. Files already exist in repo.",
-            }
-
-        commit_result = subprocess.run(
-            [
-                "git", "commit", "-m",
-                f"Add Skill: {skill_name}\n\nExtracted from: {gen.get('metadata', {}).get('source_repo', 'unknown')}\nScore: {gen.get('metadata', {}).get('score', 0)}"
-            ],
-            cwd=repo_dir, capture_output=True, text=True
-        )
-
-        if commit_result.returncode != 0:
-            return {
-                "status": "COMMIT_ERROR",
-                "error": commit_result.stderr[:500],
-            }
-
-        # Checkout new branch
-        checkout_result = subprocess.run(
-            ["git", "checkout", "-b", branch_name],
-            cwd=repo_dir, capture_output=True, text=True
-        )
-        if checkout_result.returncode != 0:
-            return {
-                "status": "CHECKOUT_ERROR",
-                "error": checkout_result.stderr[:500],
-            }
-
        # Push branch
        auth_url = clone_url.replace("http://", f"http://tonyjbala:{token}@")
+        push_result = subprocess.run(
+            ["git", "push", "-u", auth_url, f"main:{branch_name}"],
+            capture_output=True, text=True, timeout=30
+        )
+
+        if push_result.returncode != 0:
+            # Try creating from current branch
+            subprocess.run(["git", "checkout", "-b", branch_name], cwd=repo_dir, capture_output=True)
            push_result = subprocess.run(
                ["git", "push", "-u", auth_url, branch_name],
-            cwd=repo_dir, capture_output=True, text=True, timeout=30
+                capture_output=True, text=True, timeout=30
            )

        if push_result.returncode != 0:
@@ -152,19 +97,19 @@ def publish_skill(review_result, config):
        pr_url = f"{base_url}/api/v1/repos/{owner}/{repo_name}/pulls"
        pr_payload = {
            "title": f"Add Skill: {skill_name}",
-            "body": (
-                f"## Skill: {skill_name}\n\n"
+            "body": f"## Skill: {skill_name}\n\n"
                    f"**Goal:** {gen.get('metadata', {}).get('goal', '')}\n"
                    f"**Source:** {gen.get('metadata', {}).get('source_repo', '')}\n"
                    f"**Score:** {gen.get('metadata', {}).get('score', 0)}\n"
-                f"**Confidence:** {gen.get('metadata', {}).get('confidence', 0)}\n\n"
+                    f"**Confidence:** {gen.get('metadata', {}).get('confidence', 0)}\n"
+                    f"**Review:** {review_result.get('reason', '')}\n\n"
                    f"### Files\n"
-                + "".join(f"- `{f}`\n" for f in files.keys())
-            ),
+                    + "".join(f"- `{f}`\n" for f in files.keys()),
            "head": branch_name,
            "base": "main",
        }

+        import requests
        headers = {
            "Authorization": f"token {token}",
            "Content-Type": "application/json",
@@ -182,6 +127,7 @@ def publish_skill(review_result, config):
                "message": f"PR opened: {pr_data.get('html_url', '')}",
            }
        elif resp.status_code == 409:
+            # PR already exists for this branch
            return {
                "status": "PUBLISHED",
                "skill_name": skill_name,
@@ -137,8 +137,6 @@ def main():
        if publish_output.get("status") == "PUBLISHED":
            print(f"    ✓ Published! PR: {publish_output.get('pr_url', '')}")
            results["published"] += 1
-        elif publish_output.get("status") == "SKIP":
-            print(f"    ⏸ Skipped: {publish_output.get('reason', '')}")
        else:
            print(f"    ! {publish_output.get('status', '?')}: {publish_output.get('message', publish_output.get('error', ''))[:100]}")

@@ -0,0 +1,21 @@
+{
+  "run_id": "20260805-053642",
+  "started_at": "2026-08-05T05:36:42.627714",
+  "stages": {
+    "scout": {
+      "count": 2
+    },
+    "filter": {
+      "kept": 2,
+      "rejected": 0
+    }
+  },
+  "results": {
+    "extracted": 0,
+    "scored": 0,
+    "generated": 0,
+    "reviewed": 0,
+    "published": 0
+  },
+  "ended_at": "2026-08-05T05:36:49.213968"
+}
@@ -0,0 +1,21 @@
+{
+  "run_id": "20260805-053718",
+  "started_at": "2026-08-05T05:37:18.169016",
+  "stages": {
+    "scout": {
+      "count": 2
+    },
+    "filter": {
+      "kept": 2,
+      "rejected": 0
+    }
+  },
+  "results": {
+    "extracted": 0,
+    "scored": 0,
+    "generated": 0,
+    "reviewed": 0,
+    "published": 0
+  },
+  "ended_at": "2026-08-05T05:38:25.179277"
+}
@@ -0,0 +1,21 @@
+{
+  "run_id": "20260805-054839",
+  "started_at": "2026-08-05T05:48:39.344784",
+  "stages": {
+    "scout": {
+      "count": 5
+    },
+    "filter": {
+      "kept": 5,
+      "rejected": 0
+    }
+  },
+  "results": {
+    "extracted": 0,
+    "scored": 0,
+    "generated": 0,
+    "reviewed": 0,
+    "published": 0
+  },
+  "ended_at": "2026-08-05T05:48:50.960254"
+}
@@ -0,0 +1,21 @@
+{
+  "run_id": "20260805-054930",
+  "started_at": "2026-08-05T05:49:30.857560",
+  "stages": {
+    "scout": {
+      "count": 5
+    },
+    "filter": {
+      "kept": 5,
+      "rejected": 0
+    }
+  },
+  "results": {
+    "extracted": 0,
+    "scored": 0,
+    "generated": 0,
+    "reviewed": 0,
+    "published": 0
+  },
+  "ended_at": "2026-08-05T05:49:45.411491"
+}
@@ -0,0 +1,21 @@
+{
+  "run_id": "20260805-055041",
+  "started_at": "2026-08-05T05:50:41.871225",
+  "stages": {
+    "scout": {
+      "count": 5
+    },
+    "filter": {
+      "kept": 5,
+      "rejected": 0
+    }
+  },
+  "results": {
+    "extracted": 0,
+    "scored": 0,
+    "generated": 0,
+    "reviewed": 0,
+    "published": 0
+  },
+  "ended_at": "2026-08-05T05:50:57.051862"
+}
@@ -1,84 +0,0 @@
---
-name: agent-supervisor
-version: 1.0.0
-description: Demonstrate a supervisor-worker architecture for intelligent task delegation
-  and real-time decision-making.
-inputs:
- name: OPENAI_API_KEY
-  description: OpenAI API key for language models.
- name: TAVILY_API_KEY
-  description: Tavily API key for search functionality.
-steps:
- step: 1
-  action: Load environment variables.
-  details: Set the OPENAI_API_KEY and TAVILY_API_KEY environment variables.
- step: 2
-  action: Configure LangChain tools.
-  details: Initialize TavilySearchResults and PythonREPLTool.
- step: 3
-  action: Define agent nodes.
-  details: Create functions for the Researcher and Coder agents that process state
-    through their respective tasks.
- step: 4
-  action: Set up supervisor agent.
-  details: Create a supervisor agent function that decides which worker should act
-    next based on user input.
- step: 5
-  action: Build state graph.
-  details: Construct the state graph with nodes for each agent and edges connecting
-    them to the supervisor node.
- step: 6
-  action: Add conditional edges.
-  details: Define conditions for transitioning between agents based on their responses.
- step: 7
-  action: Compile graph.
-  details: Compile the state graph into a runnable workflow.
- step: 8
-  action: Run example queries.
-  details: Stream through the workflow with example inputs to demonstrate its functionality.
-outputs:
- name: 'Example 1: Code Hello World'
-  description: A demonstration of coding a simple hello world program.
- name: 'Example 2: Research Report'
-  description: A demonstration of researching and writing a brief report on pikas.
-tags: []
-metadata:
-  source_repo: https://github.com/extrawest/multi_agent_workflow_demo_in_langgraph.git
-  extracted_at: ''
-  confidence: 0.9
---
-
-# agent-supervisor
-
-Demonstrate a supervisor-worker architecture for intelligent task delegation and real-time decision-making.
-
-## Steps
-
-1. {'step': 1, 'action': 'Load environment variables.', 'details': 'Set the OPENAI_API_KEY and TAVILY_API_KEY environment variables.'}
-2. {'step': 2, 'action': 'Configure LangChain tools.', 'details': 'Initialize TavilySearchResults and PythonREPLTool.'}
-3. {'step': 3, 'action': 'Define agent nodes.', 'details': 'Create functions for the Researcher and Coder agents that process state through their respective tasks.'}
-4. {'step': 4, 'action': 'Set up supervisor agent.', 'details': 'Create a supervisor agent function that decides which worker should act next based on user input.'}
-5. {'step': 5, 'action': 'Build state graph.', 'details': 'Construct the state graph with nodes for each agent and edges connecting them to the supervisor node.'}
-6. {'step': 6, 'action': 'Add conditional edges.', 'details': 'Define conditions for transitioning between agents based on their responses.'}
-7. {'step': 7, 'action': 'Compile graph.', 'details': 'Compile the state graph into a runnable workflow.'}
-8. {'step': 8, 'action': 'Run example queries.', 'details': 'Stream through the workflow with example inputs to demonstrate its functionality.'}
-
-## Inputs
-
- {'name': 'OPENAI_API_KEY', 'description': 'OpenAI API key for language models.'}
- {'name': 'TAVILY_API_KEY', 'description': 'Tavily API key for search functionality.'}
-
-## Outputs
-
- {'name': 'Example 1: Code Hello World', 'description': 'A demonstration of coding a simple hello world program.'}
- {'name': 'Example 2: Research Report', 'description': 'A demonstration of researching and writing a brief report on pikas.'}
-
-## Failure Modes
-
- {'mode': 'Invalid API keys', 'description': 'The workflow may fail if the provided API keys are invalid or expired.'}
- {'mode': 'Insufficient permissions', 'description': 'The workflow may fail if the user does not have sufficient permissions to use the Tavily search functionality.'}
-
-## Source
-
-Extracted from: [https://github.com/extrawest/multi_agent_workflow_demo_in_langgraph.git](https://github.com/extrawest/multi_agent_workflow_demo_in_langgraph.git)
-Confidence: 0.9
@@ -1,6 +0,0 @@
-# Commands: agent-supervisor
-
-## Available Commands
-
- `/skill agent-supervisor` — Load this skill
- `/run agent-supervisor` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: agent-supervisor
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: {'name': 'OPENAI_API_KEY', 'description': 'OpenAI API key for language models.'}, {'name': 'TAVILY_API_KEY', 'description': 'Tavily API key for search functionality.'}
-# Process: {'step': 1, 'action': 'Load environment variables.', 'details': 'Set the OPENAI_API_KEY and TAVILY_API_KEY environment variables.'} → {'step': 2, 'action': 'Configure LangChain tools.', 'details': 'Initialize TavilySearchResults and PythonREPLTool.'} → {'step': 3, 'action': 'Define agent nodes.', 'details': 'Create functions for the Researcher and Coder agents that process state through their respective tasks.'}
-# Outputs: {'name': 'Example 1: Code Hello World', 'description': 'A demonstration of coding a simple hello world program.'}, {'name': 'Example 2: Research Report', 'description': 'A demonstration of researching and writing a brief report on pikas.'}
-```
@@ -1,81 +0,0 @@
-{
-  "name": "agent-supervisor",
-  "version": "1.0.0",
-  "goal": "Demonstrate a supervisor-worker architecture for intelligent task delegation and real-time decision-making.",
-  "inputs": [
-    {
-      "name": "OPENAI_API_KEY",
-      "description": "OpenAI API key for language models."
-    },
-    {
-      "name": "TAVILY_API_KEY",
-      "description": "Tavily API key for search functionality."
-    }
-  ],
-  "steps": [
-    {
-      "step": 1,
-      "action": "Load environment variables.",
-      "details": "Set the OPENAI_API_KEY and TAVILY_API_KEY environment variables."
-    },
-    {
-      "step": 2,
-      "action": "Configure LangChain tools.",
-      "details": "Initialize TavilySearchResults and PythonREPLTool."
-    },
-    {
-      "step": 3,
-      "action": "Define agent nodes.",
-      "details": "Create functions for the Researcher and Coder agents that process state through their respective tasks."
-    },
-    {
-      "step": 4,
-      "action": "Set up supervisor agent.",
-      "details": "Create a supervisor agent function that decides which worker should act next based on user input."
-    },
-    {
-      "step": 5,
-      "action": "Build state graph.",
-      "details": "Construct the state graph with nodes for each agent and edges connecting them to the supervisor node."
-    },
-    {
-      "step": 6,
-      "action": "Add conditional edges.",
-      "details": "Define conditions for transitioning between agents based on their responses."
-    },
-    {
-      "step": 7,
-      "action": "Compile graph.",
-      "details": "Compile the state graph into a runnable workflow."
-    },
-    {
-      "step": 8,
-      "action": "Run example queries.",
-      "details": "Stream through the workflow with example inputs to demonstrate its functionality."
-    }
-  ],
-  "outputs": [
-    {
-      "name": "Example 1: Code Hello World",
-      "description": "A demonstration of coding a simple hello world program."
-    },
-    {
-      "name": "Example 2: Research Report",
-      "description": "A demonstration of researching and writing a brief report on pikas."
-    }
-  ],
-  "failure_modes": [
-    {
-      "mode": "Invalid API keys",
-      "description": "The workflow may fail if the provided API keys are invalid or expired."
-    },
-    {
-      "mode": "Insufficient permissions",
-      "description": "The workflow may fail if the user does not have sufficient permissions to use the Tavily search functionality."
-    }
-  ],
-  "confidence": 0.9,
-  "explanation": "This workflow demonstrates a hierarchical multi-agent system where a supervisor agent makes routing decisions based on user input, delegating tasks to specialized worker agents (Researcher and Coder). It is designed to be reusable for similar task delegation scenarios.",
-  "source_repo": "https://github.com/extrawest/multi_agent_workflow_demo_in_langgraph.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: agent-supervisor
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,96 +0,0 @@
---
-name: blacknode-graph-workflow
-version: 1.0.0
-description: Build and execute node-based AI workflows with LLM agents and processing
-  nodes
-inputs:
- Model configuration (NIM_MODEL, API keys for NVIDIA NIM, OpenAI, Anthropic)
- Node definitions with specified inputs and outputs (Literal, LLMAgent, FileWrite,
-  etc.)
- Data sources (URLs, text content, or other inputs for the workflow)
-steps:
- Initialize a blacknode.Graph instance to create the workflow structure
- Add nodes to the graph with defined inputs and outputs (e.g., Literal, LLMAgent,
-  FileWrite)
- Define edges connecting nodes to establish data flow between them
- Execute the graph using cook() to run the workflow and generate outputs
-outputs:
- Processed results from the final node (e.g., printed text, written files, or generated
-  data)
- Graph execution status and any errors encountered during execution
-tags: []
-metadata:
-  source_repo: https://github.com/temiroff/Blacknode.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# blacknode-graph-workflow
-
-Build and execute node-based AI workflows with LLM agents and processing nodes
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install blacknode (core package) anthropic>=0.25 openai>=1.0 petgraph (for graph operations)
-```
-
-**Setup steps:**
-
-1. Install blacknode package: pip install blacknode
-1. Configure model API keys (NIM_API_KEY, OPENAI_API_KEY, etc.) in .env or editor
-1. Create a Graph instance and add nodes with inputs/outputs
-1. Define node connections in g._edges list
-1. Execute with g.cook() to run the workflow and capture results
-
-## Key Files
-
- `blacknode/blacknode.py (Graph class implementation)`
- `examples/hello_agent.py (simple LLM agent workflow)`
- `examples/converted_nvidia_nim.py (NIM model workflow)`
-
-## Steps
-
-1. Initialize a blacknode.Graph instance to create the workflow structure
-2. Add nodes to the graph with defined inputs and outputs (e.g., Literal, LLMAgent, FileWrite)
-3. Define edges connecting nodes to establish data flow between them
-4. Execute the graph using cook() to run the workflow and generate outputs
-
-## Implementation Details
-
-```python
-g = bn.Graph()
-```
-
-```python
-g._edges = [{'from': 'model', 'from_port': 'value', 'to': 'agent', 'to_port': 'model'}]
-```
-
-```python
-result = g.cook(output_node, 'value')
-```
-
-## Inputs
-
- Model configuration (NIM_MODEL, API keys for NVIDIA NIM, OpenAI, Anthropic)
- Node definitions with specified inputs and outputs (Literal, LLMAgent, FileWrite, etc.)
- Data sources (URLs, text content, or other inputs for the workflow)
-
-## Outputs
-
- Processed results from the final node (e.g., printed text, written files, or generated data)
- Graph execution status and any errors encountered during execution
-
-## Failure Modes
-
- Missing or invalid model API key causing graph initialization failure
- Incorrect node connections or missing edge definitions leading to runtime errors
- Model not found or unavailable in the specified environment causing execution failure
- Graph edges not properly defined or mismatched causing cook() to fail
-
-## Source
-
-Extracted from: [https://github.com/temiroff/Blacknode.git](https://github.com/temiroff/Blacknode.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: blacknode-graph-workflow
-
-## Available Commands
-
- `/skill blacknode-graph-workflow` — Load this skill
- `/run blacknode-graph-workflow` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: blacknode-graph-workflow
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: Model configuration (NIM_MODEL, API keys for NVIDIA NIM, OpenAI, Anthropic), Node definitions with specified inputs and outputs (Literal, LLMAgent, FileWrite, etc.), Data sources (URLs, text content, or other inputs for the workflow)
-# Process: Initialize a blacknode.Graph instance to create the workflow structure → Add nodes to the graph with defined inputs and outputs (e.g., Literal, LLMAgent, FileWrite) → Define edges connecting nodes to establish data flow between them
-# Outputs: Processed results from the final node (e.g., printed text, written files, or generated data), Graph execution status and any errors encountered during execution
-```
@@ -1,30 +0,0 @@
-{
-  "name": "blacknode-graph-workflow",
-  "version": "1.0.0",
-  "goal": "Build and execute node-based AI workflows with LLM agents and processing nodes",
-  "inputs": [
-    "Model configuration (NIM_MODEL, API keys for NVIDIA NIM, OpenAI, Anthropic)",
-    "Node definitions with specified inputs and outputs (Literal, LLMAgent, FileWrite, etc.)",
-    "Data sources (URLs, text content, or other inputs for the workflow)"
-  ],
-  "steps": [
-    "Initialize a blacknode.Graph instance to create the workflow structure",
-    "Add nodes to the graph with defined inputs and outputs (e.g., Literal, LLMAgent, FileWrite)",
-    "Define edges connecting nodes to establish data flow between them",
-    "Execute the graph using cook() to run the workflow and generate outputs"
-  ],
-  "outputs": [
-    "Processed results from the final node (e.g., printed text, written files, or generated data)",
-    "Graph execution status and any errors encountered during execution"
-  ],
-  "failure_modes": [
-    "Missing or invalid model API key causing graph initialization failure",
-    "Incorrect node connections or missing edge definitions leading to runtime errors",
-    "Model not found or unavailable in the specified environment causing execution failure",
-    "Graph edges not properly defined or mismatched causing cook() to fail"
-  ],
-  "confidence": 0.95,
-  "explanation": "Blacknode provides a standardized Graph-based workflow pattern where users create node graphs using the blacknode.Graph class. This pattern is reusable across projects as it follows a consistent structure: initialize a graph, add nodes with defined inputs/outputs, connect them with edges, and execute with cook(). The examples demonstrate this pattern with LLM agents and text processing pipelines, making it adaptable to various robotics and AI workflows.",
-  "source_repo": "https://github.com/temiroff/Blacknode.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: blacknode-graph-workflow
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,67 +0,0 @@
---
-name: blacknode-text-concatenation-workflow
-version: 1.0.0
-description: Concatenate two text strings using a Blacknode graph of Text, Concat,
-  and Output nodes.
-inputs:
- 'text_a: string'
- 'text_b: string'
-steps:
- Initialize a Blacknode Graph object.
- Add a Text node with parameter value set to text_a.
- Add a second Text node with parameter value set to text_b.
- Add a Concat node (no parameters required).
- Add an Output node (no parameters required).
- Connect the 'value' output port of the first Text node to the 'a' input port of
-  the Concat node.
- Connect the 'value' output port of the second Text node to the 'b' input port of
-  the Concat node.
- Connect the 'value' output port of the Concat node to the 'value' input port of
-  the Output node.
- Evaluate the graph by cooking the Output node's 'value' port to obtain the concatenated
-  result.
-outputs:
- 'concatenated_text: string'
-tags: []
-metadata:
-  source_repo: https://github.com/temiroff/Blacknode.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# blacknode-text-concatenation-workflow
-
-Concatenate two text strings using a Blacknode graph of Text, Concat, and Output nodes.
-
-## Steps
-
-1. Initialize a Blacknode Graph object.
-2. Add a Text node with parameter value set to text_a.
-3. Add a second Text node with parameter value set to text_b.
-4. Add a Concat node (no parameters required).
-5. Add an Output node (no parameters required).
-6. Connect the 'value' output port of the first Text node to the 'a' input port of the Concat node.
-7. Connect the 'value' output port of the second Text node to the 'b' input port of the Concat node.
-8. Connect the 'value' output port of the Concat node to the 'value' input port of the Output node.
-9. Evaluate the graph by cooking the Output node's 'value' port to obtain the concatenated result.
-
-## Inputs
-
- text_a: string
- text_b: string
-
-## Outputs
-
- concatenated_text: string
-
-## Failure Modes
-
- Node types 'Text', 'Concat', or 'Output' not registered in Blacknode runtime
- Port name mismatches during edge creation
- Missing input values causing empty concatenation
- Graph evaluation error if cycles or disconnected required ports
-
-## Source
-
-Extracted from: [https://github.com/temiroff/Blacknode.git](https://github.com/temiroff/Blacknode.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: blacknode-text-concatenation-workflow
-
-## Available Commands
-
- `/skill blacknode-text-concatenation-workflow` — Load this skill
- `/run blacknode-text-concatenation-workflow` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: blacknode-text-concatenation-workflow
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: text_a: string, text_b: string
-# Process: Initialize a Blacknode Graph object. → Add a Text node with parameter value set to text_a. → Add a second Text node with parameter value set to text_b.
-# Outputs: concatenated_text: string
-```
@@ -1,33 +0,0 @@
-{
-  "name": "blacknode-text-concatenation-workflow",
-  "version": "1.0.0",
-  "goal": "Concatenate two text strings using a Blacknode graph of Text, Concat, and Output nodes.",
-  "inputs": [
-    "text_a: string",
-    "text_b: string"
-  ],
-  "steps": [
-    "Initialize a Blacknode Graph object.",
-    "Add a Text node with parameter value set to text_a.",
-    "Add a second Text node with parameter value set to text_b.",
-    "Add a Concat node (no parameters required).",
-    "Add an Output node (no parameters required).",
-    "Connect the 'value' output port of the first Text node to the 'a' input port of the Concat node.",
-    "Connect the 'value' output port of the second Text node to the 'b' input port of the Concat node.",
-    "Connect the 'value' output port of the Concat node to the 'value' input port of the Output node.",
-    "Evaluate the graph by cooking the Output node's 'value' port to obtain the concatenated result."
-  ],
-  "outputs": [
-    "concatenated_text: string"
-  ],
-  "failure_modes": [
-    "Node types 'Text', 'Concat', or 'Output' not registered in Blacknode runtime",
-    "Port name mismatches during edge creation",
-    "Missing input values causing empty concatenation",
-    "Graph evaluation error if cycles or disconnected required ports"
-  ],
-  "confidence": 0.95,
-  "explanation": "Extracted from examples/converted_text_pipeline.py and referenced templates/text-pipeline.json in the Blacknode repo. This workflow is a foundational, dependency-free pattern for building directed graphs of typed nodes and is applicable to any simple data combination task.",
-  "source_repo": "https://github.com/temiroff/Blacknode.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: blacknode-text-concatenation-workflow
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,77 +0,0 @@
---
-name: code-review-agent-workflow
-version: 1.0.0
-description: Automate the code review process using a multi-step workflow with human-in-the-loop
-  approval.
-inputs:
- Sample diff of code changes (str)
- Repo context (dict)
-steps:
- 'Step 1: Build the graph for the code review agent using `build_graph()` from `agentkit.workflow.code_review.graph`'
- 'Step 2: Invoke the graph with initial parameters including sample diff, repo context,
-  user ID, and other metadata'
- 'Step 3: The graph processes the input through a series of steps, generating messages
-  and issues as it progresses'
-outputs:
- Final result containing processed messages and issues (dict)
-tags: []
-metadata:
-  source_repo: https://github.com/itszhaoziyan-n/AgentKit.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# code-review-agent-workflow
-
-Automate the code review process using a multi-step workflow with human-in-the-loop approval.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install langgraph>=0.3 langchain-core>=0.3 langchain-anthropic>=0.3 langfuse>=2.0 mcp[server]>=1.24,<2.0 langchain-mcp-adapters>=0.1 tenacity>=9.0 fastapi>=0.115 uvicorn[standard]>=0.32 psycopg[binary]>=3.1 langgraph-checkpoint-postgres>=2.0 httpx>=0.27 python-dotenv>=1.0 redis>=5.0
-```
-
-**Setup steps:**
-
-1. cp .env.example .env
-1. docker compose up -d
-1. pip install -e '.[dev]'
-
-## Key Files
-
- `agentkit/workflow/code_review/graph.py - Contains the `build_graph` function and graph invocation logic.`
- `examples/run_code_review.py - Example script demonstrating how to run the code review agent.`
-
-## Steps
-
-1. Step 1: Build the graph for the code review agent using `build_graph()` from `agentkit.workflow.code_review.graph`
-2. Step 2: Invoke the graph with initial parameters including sample diff, repo context, user ID, and other metadata
-3. Step 3: The graph processes the input through a series of steps, generating messages and issues as it progresses
-
-## Implementation Details
-
-```python
-graph = build_graph()
-thread_id = str(uuid.uuid4())
-result = graph.invoke(...)
-```
-
-## Inputs
-
- Sample diff of code changes (str)
- Repo context (dict)
-
-## Outputs
-
- Final result containing processed messages and issues (dict)
-
-## Failure Modes
-
- Specific failure scenario with mitigation: If the `build_graph()` function fails to initialize properly, ensure all required dependencies are correctly installed.
-
-## Source
-
-Extracted from: [https://github.com/itszhaoziyan-n/AgentKit.git](https://github.com/itszhaoziyan-n/AgentKit.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: code-review-agent-workflow
-
-## Available Commands
-
- `/skill code-review-agent-workflow` — Load this skill
- `/run code-review-agent-workflow` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: code-review-agent-workflow
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: Sample diff of code changes (str), Repo context (dict)
-# Process: Step 1: Build the graph for the code review agent using `build_graph()` from `agentkit.workflow.code_review.graph` → Step 2: Invoke the graph with initial parameters including sample diff, repo context, user ID, and other metadata → Step 3: The graph processes the input through a series of steps, generating messages and issues as it progresses
-# Outputs: Final result containing processed messages and issues (dict)
-```
@@ -1,24 +0,0 @@
-{
-  "name": "code-review-agent-workflow",
-  "version": "1.0.0",
-  "goal": "Automate the code review process using a multi-step workflow with human-in-the-loop approval.",
-  "inputs": [
-    "Sample diff of code changes (str)",
-    "Repo context (dict)"
-  ],
-  "steps": [
-    "Step 1: Build the graph for the code review agent using `build_graph()` from `agentkit.workflow.code_review.graph`",
-    "Step 2: Invoke the graph with initial parameters including sample diff, repo context, user ID, and other metadata",
-    "Step 3: The graph processes the input through a series of steps, generating messages and issues as it progresses"
-  ],
-  "outputs": [
-    "Final result containing processed messages and issues (dict)"
-  ],
-  "failure_modes": [
-    "Specific failure scenario with mitigation: If the `build_graph()` function fails to initialize properly, ensure all required dependencies are correctly installed."
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow is reusable for any code review process that requires a multi-step analysis and human approval.",
-  "source_repo": "https://github.com/itszhaoziyan-n/AgentKit.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: code-review-agent-workflow
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,115 +0,0 @@
---
-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
@@ -1,6 +0,0 @@
-# Commands: langgraph-agent-workflow
-
-## Available Commands
-
- `/skill langgraph-agent-workflow` — Load this skill
- `/run langgraph-agent-workflow` — Execute workflow
@@ -1,10 +0,0 @@
-# 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
-```
@@ -1,36 +0,0 @@
-{
-  "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
-}
@@ -1,9 +0,0 @@
-# Tests: langgraph-agent-workflow
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -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
@@ -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
@@ -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)
-```
@@ -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
-}
@@ -1,9 +0,0 @@
-# Tests: langgraph-multi-agent-router
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,83 +0,0 @@
---
-name: langgraph-workflow-creation
-version: 1.0.0
-description: Create a LangGraph workflow to gather facts using SerperDevTool and process
-  them with an AI agent.
-inputs:
- API Key for SerperDevTool
- Search Query
-steps:
- 'Step 1: Import necessary modules from langgraph and langchain libraries'
- 'Step 2: Create a LangGraph agent using `langgraph.create_react_agent` function
-  with SerperDevTool as the tool node'
- 'Step 3: Define the search query and pass it to the agent for fact gathering'
- 'Step 4: Process the gathered facts within the AI agent'
-outputs:
- Processed Facts
-tags: []
-metadata:
-  source_repo: https://github.com/jkmaina/LangGraphProjects.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# langgraph-workflow-creation
-
-Create a LangGraph workflow to gather facts using SerperDevTool and process them with an AI agent.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install langchain serperdev
-```
-
-**Setup steps:**
-
-1. Install required libraries: pip install langchain serperdev
-1. Add API key to .env file: OPENAPI_API_KEY=your_api_key
-
-## Key Files
-
- `agent.py - Contains the LangGraph agent creation logic`
- `tool_node.py - Defines the SerperDevTool node`
-
-## Steps
-
-1. Step 1: Import necessary modules from langgraph and langchain libraries
-2. Step 2: Create a LangGraph agent using `langgraph.create_react_agent` function with SerperDevTool as the tool node
-3. Step 3: Define the search query and pass it to the agent for fact gathering
-4. Step 4: Process the gathered facts within the AI agent
-
-## Implementation Details
-
-```python
-import langgraph
-from serperdev import SerperDevTool
-
-def create_agent(api_key, query):
-    tool = SerperDevTool(api_key)
-    agent = langgraph.create_react_agent(tool=tool)
-    facts = agent.run(query)
-    return process_facts(facts)
-```
-
-## Inputs
-
- API Key for SerperDevTool
- Search Query
-
-## Outputs
-
- Processed Facts
-
-## Failure Modes
-
- API Key not provided
- Invalid Search Query
-
-## Source
-
-Extracted from: [https://github.com/jkmaina/LangGraphProjects.git](https://github.com/jkmaina/LangGraphProjects.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: langgraph-workflow-creation
-
-## Available Commands
-
- `/skill langgraph-workflow-creation` — Load this skill
- `/run langgraph-workflow-creation` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: langgraph-workflow-creation
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: API Key for SerperDevTool, Search Query
-# Process: Step 1: Import necessary modules from langgraph and langchain libraries → Step 2: Create a LangGraph agent using `langgraph.create_react_agent` function with SerperDevTool as the tool node → Step 3: Define the search query and pass it to the agent for fact gathering
-# Outputs: Processed Facts
-```
@@ -1,26 +0,0 @@
-{
-  "name": "langgraph-workflow-creation",
-  "version": "1.0.0",
-  "goal": "Create a LangGraph workflow to gather facts using SerperDevTool and process them with an AI agent.",
-  "inputs": [
-    "API Key for SerperDevTool",
-    "Search Query"
-  ],
-  "steps": [
-    "Step 1: Import necessary modules from langgraph and langchain libraries",
-    "Step 2: Create a LangGraph agent using `langgraph.create_react_agent` function with SerperDevTool as the tool node",
-    "Step 3: Define the search query and pass it to the agent for fact gathering",
-    "Step 4: Process the gathered facts within the AI agent"
-  ],
-  "outputs": [
-    "Processed Facts"
-  ],
-  "failure_modes": [
-    "API Key not provided",
-    "Invalid Search Query"
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow is specific to fact gathering and can be adapted for different search queries or tools.",
-  "source_repo": "https://github.com/jkmaina/LangGraphProjects.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: langgraph-workflow-creation
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,98 +0,0 @@
---
-name: mcp-server-setup
-version: 1.0.0
-description: Set up an MCP server to integrate PipesHub with any MCP-compatible client.
-inputs:
- MCP server configuration details
- PipesHub credentials
-steps:
- 'Step 1: Clone the `pipeshub-ai/mcp-server` repository using `git clone https://github.com/pipeshub-ai/mcp-server.git`'
- 'Step 2: Navigate to the cloned directory with `cd mcp-server`'
- 'Step 3: Run the interactive installer by executing `./install.sh`'
- 'Step 4: Follow the prompts in the installer to configure the server, including
-  setting up graph DB, message broker, and KV store'
- 'Step 5: The installer will generate a `.env` file with necessary environment variables.
-  Ensure these are correctly set'
- 'Step 6: Start the MCP server by running `docker-compose up -d`'
-outputs:
- Running MCP server
- .env file generated
-tags: []
-metadata:
-  source_repo: https://github.com/pipeshub-ai/pipeshub-ai.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# mcp-server-setup
-
-Set up an MCP server to integrate PipesHub with any MCP-compatible client.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install docker docker-compose
-```
-
-**Setup steps:**
-
-1. Ensure Docker and Docker Compose are installed on your system.
-1. Clone the `pipeshub-ai/mcp-server` repository using `git clone https://github.com/pipeshub-ai/mcp-server.git`
-
-## Key Files
-
- `path/to/install.sh - Script to run the interactive installer`
- `path/to/docker-compose.yml - Configuration for Docker services`
-
-## Steps
-
-1. Step 1: Clone the `pipeshub-ai/mcp-server` repository using `git clone https://github.com/pipeshub-ai/mcp-server.git`
-2. Step 2: Navigate to the cloned directory with `cd mcp-server`
-3. Step 3: Run the interactive installer by executing `./install.sh`
-4. Step 4: Follow the prompts in the installer to configure the server, including setting up graph DB, message broker, and KV store
-5. Step 5: The installer will generate a `.env` file with necessary environment variables. Ensure these are correctly set
-6. Step 6: Start the MCP server by running `docker-compose up -d`
-
-## Implementation Details
-
-```python
-```bash
-./install.sh
-```
-Run this script to start the installation process.
-```
-
-```python
-```yaml
-docker-compose:
-  version: '3.9'
-services:
-  mcp-server:
-    image: pipeshubai/mcp-server:latest
-    environment:
-      - PIPESHUB_API_KEY=your_api_key_here
-```
-This snippet shows how to configure the Docker Compose file.
-```
-
-## Inputs
-
- MCP server configuration details
- PipesHub credentials
-
-## Outputs
-
- Running MCP server
- .env file generated
-
-## Failure Modes
-
- Installer fails to run due to missing dependencies or incorrect configuration
- Docker Compose setup issues preventing server from starting
-
-## Source
-
-Extracted from: [https://github.com/pipeshub-ai/pipeshub-ai.git](https://github.com/pipeshub-ai/pipeshub-ai.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: mcp-server-setup
-
-## Available Commands
-
- `/skill mcp-server-setup` — Load this skill
- `/run mcp-server-setup` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: mcp-server-setup
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: MCP server configuration details, PipesHub credentials
-# Process: Step 1: Clone the `pipeshub-ai/mcp-server` repository using `git clone https://github.com/pipeshub-ai/mcp-server.git` → Step 2: Navigate to the cloned directory with `cd mcp-server` → Step 3: Run the interactive installer by executing `./install.sh`
-# Outputs: Running MCP server, .env file generated
-```
@@ -1,29 +0,0 @@
-{
-  "name": "mcp-server-setup",
-  "version": "1.0.0",
-  "goal": "Set up an MCP server to integrate PipesHub with any MCP-compatible client.",
-  "inputs": [
-    "MCP server configuration details",
-    "PipesHub credentials"
-  ],
-  "steps": [
-    "Step 1: Clone the `pipeshub-ai/mcp-server` repository using `git clone https://github.com/pipeshub-ai/mcp-server.git`",
-    "Step 2: Navigate to the cloned directory with `cd mcp-server`",
-    "Step 3: Run the interactive installer by executing `./install.sh`",
-    "Step 4: Follow the prompts in the installer to configure the server, including setting up graph DB, message broker, and KV store",
-    "Step 5: The installer will generate a `.env` file with necessary environment variables. Ensure these are correctly set",
-    "Step 6: Start the MCP server by running `docker-compose up -d`"
-  ],
-  "outputs": [
-    "Running MCP server",
-    ".env file generated"
-  ],
-  "failure_modes": [
-    "Installer fails to run due to missing dependencies or incorrect configuration",
-    "Docker Compose setup issues preventing server from starting"
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow is specific but can be adapted for different deployment environments and configurations.",
-  "source_repo": "https://github.com/pipeshub-ai/pipeshub-ai.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: mcp-server-setup
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,84 +0,0 @@
---
-name: multi-agent-sequential-workflow
-version: 1.0.0
-description: Gather and process information from multiple agents to generate a comprehensive
-  travel guide.
-inputs:
- User query with location
-steps:
- 'Step 1: Researcher agent (agent.py) uses LangGraph create_react_agent with BedrockModel
-  to gather raw facts about the destination.'
- 'Step 2: Travel Guide Generator agent (agent.py) synthesizes the gathered data into
-  a structured travel guide based on the user''s request and raw information provided
-  by the researcher.'
- 'Step 3: Writer agent (agent.py) formats the final response, including the structured
-  guide content and prominently features the ''Suggested Web Pages'' section.'
-outputs:
- Structured travel guide with key sections
- Final client response
-tags: []
-metadata:
-  source_repo: https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# multi-agent-sequential-workflow
-
-Gather and process information from multiple agents to generate a comprehensive travel guide.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install python3 fastapi uvicorn strands bedrock-model
-```
-
-**Setup steps:**
-
-1. Install required dependencies using pip
-1. Set up environment variables for API keys and model IDs
-
-## Key Files
-
- `agents/aws_strands/05-agent-strands-multiagent-workflow-sequential/agent.py - Contains the multi-agent workflow logic.`
- `agents/aws_strands/05-agent-strands-multiagent-workflow-sequential/app.py - FastAPI app to handle user queries.`
-
-## Steps
-
-1. Step 1: Researcher agent (agent.py) uses LangGraph create_react_agent with BedrockModel to gather raw facts about the destination.
-2. Step 2: Travel Guide Generator agent (agent.py) synthesizes the gathered data into a structured travel guide based on the user's request and raw information provided by the researcher.
-3. Step 3: Writer agent (agent.py) formats the final response, including the structured guide content and prominently features the 'Suggested Web Pages' section.
-
-## Implementation Details
-
-```python
-research_output = researcher_agent(query, stream=False)
-```
-
-```python
-guide_output = travel_guide_agent(planner_prompt, stream=False)
-```
-
-```python
-final_response = writer_agent(writer_prompt, stream=False)
-```
-
-## Inputs
-
- User query with location
-
-## Outputs
-
- Structured travel guide with key sections
- Final client response
-
-## Failure Modes
-
- Network issues during API calls could lead to incomplete data collection or processing failures
-
-## Source
-
-Extracted from: [https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git](https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: multi-agent-sequential-workflow
-
-## Available Commands
-
- `/skill multi-agent-sequential-workflow` — Load this skill
- `/run multi-agent-sequential-workflow` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: multi-agent-sequential-workflow
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: User query with location
-# Process: Step 1: Researcher agent (agent.py) uses LangGraph create_react_agent with BedrockModel to gather raw facts about the destination. → Step 2: Travel Guide Generator agent (agent.py) synthesizes the gathered data into a structured travel guide based on the user's request and raw information provided by the researcher. → Step 3: Writer agent (agent.py) formats the final response, including the structured guide content and prominently features the 'Suggested Web Pages' section.
-# Outputs: Structured travel guide with key sections, Final client response
-```
@@ -1,24 +0,0 @@
-{
-  "name": "multi-agent-sequential-workflow",
-  "version": "1.0.0",
-  "goal": "Gather and process information from multiple agents to generate a comprehensive travel guide.",
-  "inputs": [
-    "User query with location"
-  ],
-  "steps": [
-    "Step 1: Researcher agent (agent.py) uses LangGraph create_react_agent with BedrockModel to gather raw facts about the destination.",
-    "Step 2: Travel Guide Generator agent (agent.py) synthesizes the gathered data into a structured travel guide based on the user's request and raw information provided by the researcher.",
-    "Step 3: Writer agent (agent.py) formats the final response, including the structured guide content and prominently features the 'Suggested Web Pages' section."
-  ],
-  "outputs": [
-    "Structured travel guide with key sections",
-    "Final client response"
-  ],
-  "failure_modes": [
-    "Network issues during API calls could lead to incomplete data collection or processing failures"
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow is specific but can be adapted for other types of guides or information gathering tasks.",
-  "source_repo": "https://github.com/omerbsezer/Fast-LLM-Agent-MCP.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: multi-agent-sequential-workflow
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,113 +0,0 @@
---
-name: multi-agent-workflow-execution
-version: 1.0.0
-description: Execute multi-agent AI workflows defined in YAML blueprints by creating
-  sessions, submitting user prompts, and polling for completion until final answers
-  are returned.
-inputs:
- Blueprint ID or name (to identify the workflow to execute)
- User shortcut (authentication identifier for the user)
- User question or prompt (input to the workflow)
- Base URL of the UnifAI API (endpoint for session management)
- Polling interval (seconds between status checks during execution)
-steps:
- Resolve the blueprint ID from either direct ID or name lookup via the API, handling
-  cases where the blueprint is not found or not unique
- Create a new session from the resolved blueprint using the session creation endpoint
- Submit the session with the user's prompt to start the multi-agent workflow execution
- Poll the session status at regular intervals until the session completes, fails,
-  or is cancelled
- Retrieve and return the final answer from the completed workflow
-outputs:
- Final workflow result or answer (text or structured data)
- Session status (completed, failed, or cancelled)
- Error details if the workflow execution fails or times out
-tags: []
-metadata:
-  source_repo: https://github.com/redhat-community-ai-tools/UnifAI.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# multi-agent-workflow-execution
-
-Execute multi-agent AI workflows defined in YAML blueprints by creating sessions, submitting user prompts, and polling for completion until final answers are returned.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install requests urllib3 python-langgraph temporalio
-```
-
-**Setup steps:**
-
-1. Install Python 3.11+ and required packages (requests, langgraph, temporalio)
-1. Configure API base URL and user credentials in environment variables or config
-1. Define or select a blueprint from the available workflows in the system
-1. Run the execution_workflow.py script with blueprint ID/name and user prompt
-
-## Key Files
-
- `scripts/execution_workflow.py - Main workflow execution script`
- `multi-agent/lib/mas/engine/ - LangGraph-based orchestration modules`
- `multi-agent/lib/mas/elements/ - Node definitions (custom_agent_node, merger_node, etc.)`
- `multi-agent/lib/mas/blueprints/ - Blueprint resolution and validation logic`
-
-## Steps
-
-1. Resolve the blueprint ID from either direct ID or name lookup via the API, handling cases where the blueprint is not found or not unique
-2. Create a new session from the resolved blueprint using the session creation endpoint
-3. Submit the session with the user's prompt to start the multi-agent workflow execution
-4. Poll the session status at regular intervals until the session completes, fails, or is cancelled
-5. Retrieve and return the final answer from the completed workflow
-
-## Implementation Details
-
-```python
-resolve_blueprint_id() - Resolves blueprint by ID or name lookup with error handling
-```
-
-```python
-create_session() - Creates a new session from a blueprint via POST /user.session.create
-```
-
-```python
-submit_session() - Submits user prompt to start workflow via POST /user.session.submit
-```
-
-```python
-poll_session_status() - Polls session.stream.status at configurable intervals
-```
-
-```python
-get_final_answer() - Retrieves final output via GET /session.chat.get
-```
-
-## Inputs
-
- Blueprint ID or name (to identify the workflow to execute)
- User shortcut (authentication identifier for the user)
- User question or prompt (input to the workflow)
- Base URL of the UnifAI API (endpoint for session management)
- Polling interval (seconds between status checks during execution)
-
-## Outputs
-
- Final workflow result or answer (text or structured data)
- Session status (completed, failed, or cancelled)
- Error details if the workflow execution fails or times out
-
-## Failure Modes
-
- Blueprint not found or not unique - script exits with an error listing available blueprints
- Session creation fails - may be due to invalid blueprint ID, authentication issues, or rate limiting
- Session submission fails - could be due to network issues, invalid parameters, or API rate limits
- Polling loop times out - session may be stuck in a long-running state without progress
- Final answer retrieval fails - could be due to session cleanup or network issues after completion
-
-## Source
-
-Extracted from: [https://github.com/redhat-community-ai-tools/UnifAI.git](https://github.com/redhat-community-ai-tools/UnifAI.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: multi-agent-workflow-execution
-
-## Available Commands
-
- `/skill multi-agent-workflow-execution` — Load this skill
- `/run multi-agent-workflow-execution` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: multi-agent-workflow-execution
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: Blueprint ID or name (to identify the workflow to execute), User shortcut (authentication identifier for the user), User question or prompt (input to the workflow), Base URL of the UnifAI API (endpoint for session management), Polling interval (seconds between status checks during execution)
-# Process: Resolve the blueprint ID from either direct ID or name lookup via the API, handling cases where the blueprint is not found or not unique → Create a new session from the resolved blueprint using the session creation endpoint → Submit the session with the user's prompt to start the multi-agent workflow execution
-# Outputs: Final workflow result or answer (text or structured data), Session status (completed, failed, or cancelled), Error details if the workflow execution fails or times out
-```
@@ -1,35 +0,0 @@
-{
-  "name": "multi-agent-workflow-execution",
-  "version": "1.0.0",
-  "goal": "Execute multi-agent AI workflows defined in YAML blueprints by creating sessions, submitting user prompts, and polling for completion until final answers are returned.",
-  "inputs": [
-    "Blueprint ID or name (to identify the workflow to execute)",
-    "User shortcut (authentication identifier for the user)",
-    "User question or prompt (input to the workflow)",
-    "Base URL of the UnifAI API (endpoint for session management)",
-    "Polling interval (seconds between status checks during execution)"
-  ],
-  "steps": [
-    "Resolve the blueprint ID from either direct ID or name lookup via the API, handling cases where the blueprint is not found or not unique",
-    "Create a new session from the resolved blueprint using the session creation endpoint",
-    "Submit the session with the user's prompt to start the multi-agent workflow execution",
-    "Poll the session status at regular intervals until the session completes, fails, or is cancelled",
-    "Retrieve and return the final answer from the completed workflow"
-  ],
-  "outputs": [
-    "Final workflow result or answer (text or structured data)",
-    "Session status (completed, failed, or cancelled)",
-    "Error details if the workflow execution fails or times out"
-  ],
-  "failure_modes": [
-    "Blueprint not found or not unique - script exits with an error listing available blueprints",
-    "Session creation fails - may be due to invalid blueprint ID, authentication issues, or rate limiting",
-    "Session submission fails - could be due to network issues, invalid parameters, or API rate limits",
-    "Polling loop times out - session may be stuck in a long-running state without progress",
-    "Final answer retrieval fails - could be due to session cleanup or network issues after completion"
-  ],
-  "confidence": 0.95,
-  "explanation": "The UnifAI repository contains a concrete, reusable workflow pattern for executing multi-agent AI workflows. The scripts/execution_workflow.py script demonstrates a complete pipeline: resolving blueprints by ID or name, creating sessions from blueprints, submitting user prompts to start workflows, polling session status until completion, and retrieving final answers. This pattern can be adapted to any multi-agent workflow defined in the YAML blueprint system, making it reusable across different use cases and teams.",
-  "source_repo": "https://github.com/redhat-community-ai-tools/UnifAI.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: multi-agent-workflow-execution
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,90 +0,0 @@
---
-name: research-pipeline
-version: 1.0.0
-description: Fetch a Wikipedia page, summarise its content using an AI agent, and
-  write the summary to a file.
-inputs:
- URL of the Wikipedia page
-steps:
- 'Step 1: Import necessary modules from `_bootstrap` and `blacknode`: Run `from _bootstrap
-  import NIM_MODEL, require_nim_api_key; import blacknode as bn`'
- 'Step 2: Require NVIDIA NIM API key: Call `require_nim_api_key()` to ensure the
-  API key is set.'
- 'Step 3: Create a graph instance: Initialize `g = bn.Graph()`.'
- 'Step 4: Add nodes for URL, HTTPGet, summarisation, and file writing: `url = g.node(''Literal'',
-  value=''URL of the Wikipedia page''); fetcher = g.node(''HTTPGet''); summarise =
-  g.node(''LLMAgent'', system=''You are a technical writer. Summarise the text in
-  3 bullet points.'', model=NIM_MODEL); writer = g.node(''FileWrite'', path=''summary.txt'')`'
- 'Step 5: Connect nodes with edges: `url.out(''value'') >> fetcher.inp(''url'');
-  fetcher.out(''text'') >> summarise.inp(''prompt''); summarise.out(''text'') >> writer.inp(''text'')`'
- 'Step 6: Cook the graph to execute and get output: `result = g.cook(writer, ''path'');
-  print(f''Summary written to: {result}'')`'
-outputs:
- Path of the summary file
-tags: []
-metadata:
-  source_repo: https://github.com/temiroff/Blacknode.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# research-pipeline
-
-Fetch a Wikipedia page, summarise its content using an AI agent, and write the summary to a file.
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install anthropic>=0.25 docker>=7.1 openai>=1.0
-```
-
-**Setup steps:**
-
-1. Ensure NVIDIA NIM API key is set in the environment or editor
-1. Install required dependencies: `pip install -r requirements.txt`
-
-## Key Files
-
- `examples/research_pipeline.py - Contains the research pipeline workflow`
-
-## Steps
-
-1. Step 1: Import necessary modules from `_bootstrap` and `blacknode`: Run `from _bootstrap import NIM_MODEL, require_nim_api_key; import blacknode as bn`
-2. Step 2: Require NVIDIA NIM API key: Call `require_nim_api_key()` to ensure the API key is set.
-3. Step 3: Create a graph instance: Initialize `g = bn.Graph()`.
-4. Step 4: Add nodes for URL, HTTPGet, summarisation, and file writing: `url = g.node('Literal', value='URL of the Wikipedia page'); fetcher = g.node('HTTPGet'); summarise = g.node('LLMAgent', system='You are a technical writer. Summarise the text in 3 bullet points.', model=NIM_MODEL); writer = g.node('FileWrite', path='summary.txt')`
-5. Step 5: Connect nodes with edges: `url.out('value') >> fetcher.inp('url'); fetcher.out('text') >> summarise.inp('prompt'); summarise.out('text') >> writer.inp('text')`
-6. Step 6: Cook the graph to execute and get output: `result = g.cook(writer, 'path'); print(f'Summary written to: {result}')`
-
-## Implementation Details
-
-```python
-from _bootstrap import NIM_MODEL, require_nim_api_key; import blacknode as bn
-```
-
-```python
-url = g.node('Literal', value='https://en.wikipedia.org/w/api.php?action=query&prop=extracts&exintro=1&explaintext=1&titles=Houdini_(software)&format=json&formatversion=2&origin=*'); fetcher = g.node('HTTPGet'); summarise = g.node('LLMAgent', system='You are a technical writer. Summarise the text in 3 bullet points.', model=NIM_MODEL); writer = g.node('FileWrite', path='summary.txt')
-```
-
-```python
-url.out('value') >> fetcher.inp('url'); fetcher.out('text') >> summarise.inp('prompt'); summarise.out('text') >> writer.inp('text')
-```
-
-## Inputs
-
- URL of the Wikipedia page
-
-## Outputs
-
- Path of the summary file
-
-## Failure Modes
-
- If the URL is invalid or unreachable, the HTTPGet node will fail; if the summarisation fails, the output text might be empty
-
-## Source
-
-Extracted from: [https://github.com/temiroff/Blacknode.git](https://github.com/temiroff/Blacknode.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: research-pipeline
-
-## Available Commands
-
- `/skill research-pipeline` — Load this skill
- `/run research-pipeline` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: research-pipeline
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: URL of the Wikipedia page
-# Process: Step 1: Import necessary modules from `_bootstrap` and `blacknode`: Run `from _bootstrap import NIM_MODEL, require_nim_api_key; import blacknode as bn` → Step 2: Require NVIDIA NIM API key: Call `require_nim_api_key()` to ensure the API key is set. → Step 3: Create a graph instance: Initialize `g = bn.Graph()`.
-# Outputs: Path of the summary file
-```
@@ -1,26 +0,0 @@
-{
-  "name": "research-pipeline",
-  "version": "1.0.0",
-  "goal": "Fetch a Wikipedia page, summarise its content using an AI agent, and write the summary to a file.",
-  "inputs": [
-    "URL of the Wikipedia page"
-  ],
-  "steps": [
-    "Step 1: Import necessary modules from `_bootstrap` and `blacknode`: Run `from _bootstrap import NIM_MODEL, require_nim_api_key; import blacknode as bn`",
-    "Step 2: Require NVIDIA NIM API key: Call `require_nim_api_key()` to ensure the API key is set.",
-    "Step 3: Create a graph instance: Initialize `g = bn.Graph()`.",
-    "Step 4: Add nodes for URL, HTTPGet, summarisation, and file writing: `url = g.node('Literal', value='URL of the Wikipedia page'); fetcher = g.node('HTTPGet'); summarise = g.node('LLMAgent', system='You are a technical writer. Summarise the text in 3 bullet points.', model=NIM_MODEL); writer = g.node('FileWrite', path='summary.txt')`",
-    "Step 5: Connect nodes with edges: `url.out('value') >> fetcher.inp('url'); fetcher.out('text') >> summarise.inp('prompt'); summarise.out('text') >> writer.inp('text')`",
-    "Step 6: Cook the graph to execute and get output: `result = g.cook(writer, 'path'); print(f'Summary written to: {result}')`"
-  ],
-  "outputs": [
-    "Path of the summary file"
-  ],
-  "failure_modes": [
-    "If the URL is invalid or unreachable, the HTTPGet node will fail; if the summarisation fails, the output text might be empty"
-  ],
-  "confidence": 0.95,
-  "explanation": "This workflow can be adapted to fetch and summarise any Wikipedia page or similar content source.",
-  "source_repo": "https://github.com/temiroff/Blacknode.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: research-pipeline
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors
@@ -1,94 +0,0 @@
---
-name: three-tier-evaluation-pipeline
-version: 1.0.0
-description: Run tasks through three evaluation tiers (Run, Trace, Thread) to produce
-  comprehensive reports with human-in-the-loop validation
-inputs:
- query/input text for the task
- search results (for trace tier evaluation)
- evaluation criteria and thresholds
-steps:
- 'Step 1: Execute the main task using the Run tier of the evaluation pipeline (agentkit/runtime/LangGraph
-  engine) to generate initial outputs and results'
- 'Step 2: Run the Trace tier where an LLM-as-Judge evaluates the output against defined
-  criteria, generating detailed analysis and scoring'
- 'Step 3: Execute the Thread tier which facilitates human-in-the-loop discussion,
-  approval, and iterative refinement of the output'
-outputs:
- Final consolidated report combining results from all three tiers
- Detailed scores and metrics per tier
- Threaded discussion logs for human review and approval
-tags: []
-metadata:
-  source_repo: https://github.com/itszhaoziyan-n/AgentKit.git
-  extracted_at: ''
-  confidence: 0.95
---
-
-# three-tier-evaluation-pipeline
-
-Run tasks through three evaluation tiers (Run, Trace, Thread) to produce comprehensive reports with human-in-the-loop validation
-
-## Setup
-
-**Dependencies:**
-
-```text
-pip install langgraph>=0.3 langchain-core>=0.3 langchain-anthropic>=0.3 langfuse>=2.0 mcp[server]>=1.24 tenacity>=9.0 fastapi>=0.115 psycopg[binary]>=3.1
-```
-
-**Setup steps:**
-
-1. Install dependencies with pip install -e .[dev]
-1. Start infrastructure: docker compose up -d (PostgreSQL, Langfuse, MCP server)
-1. Configure environment variables (DATABASE_URL, MCP_API_KEY, etc.)
-1. Run the pipeline: python -m eval.runner --tiers run,thread,trace
-
-## Key Files
-
- `eval/ - contains the three-tier evaluation logic`
- `scripts/ci_gate.py - threshold update and benchmark validation`
- `agentkit/runtime/ - LangGraph engine for state management and graph execution`
-
-## Steps
-
-1. Step 1: Execute the main task using the Run tier of the evaluation pipeline (agentkit/runtime/LangGraph engine) to generate initial outputs and results
-2. Step 2: Run the Trace tier where an LLM-as-Judge evaluates the output against defined criteria, generating detailed analysis and scoring
-3. Step 3: Execute the Thread tier which facilitates human-in-the-loop discussion, approval, and iterative refinement of the output
-
-## Implementation Details
-
-```python
-The eval/ directory implements Run, Trace, and Thread stages with configurable tiers
-```
-
-```python
-Benchmark suite (40 test cases) validates the pipeline's reliability
-```
-
-```python
-CI/CD workflows (ci.yml, eval-fast.yml, eval-trace.yml) orchestrate the evaluation pipeline
-```
-
-## Inputs
-
- query/input text for the task
- search results (for trace tier evaluation)
- evaluation criteria and thresholds
-
-## Outputs
-
- Final consolidated report combining results from all three tiers
- Detailed scores and metrics per tier
- Threaded discussion logs for human review and approval
-
-## Failure Modes
-
- If the Run tier fails (e.g., code execution error), the pipeline can retry but may produce incomplete outputs
- If the Trace tier LLM-as-Judge produces low-quality evaluations, the Thread tier may need additional human intervention
- Threshold mismatches between tiers could cause the pipeline to exit early or require manual adjustment
-
-## Source
-
-Extracted from: [https://github.com/itszhaoziyan-n/AgentKit.git](https://github.com/itszhaoziyan-n/AgentKit.git)
-Confidence: 0.95
@@ -1,6 +0,0 @@
-# Commands: three-tier-evaluation-pipeline
-
-## Available Commands
-
- `/skill three-tier-evaluation-pipeline` — Load this skill
- `/run three-tier-evaluation-pipeline` — Execute workflow
@@ -1,10 +0,0 @@
-# Examples: three-tier-evaluation-pipeline
-
-## Usage Example
-
-```python
-# How to use this skill
-# Inputs: query/input text for the task, search results (for trace tier evaluation), evaluation criteria and thresholds
-# Process: Step 1: Execute the main task using the Run tier of the evaluation pipeline (agentkit/runtime/LangGraph engine) to generate initial outputs and results → Step 2: Run the Trace tier where an LLM-as-Judge evaluates the output against defined criteria, generating detailed analysis and scoring → Step 3: Execute the Thread tier which facilitates human-in-the-loop discussion, approval, and iterative refinement of the output
-# Outputs: Final consolidated report combining results from all three tiers, Detailed scores and metrics per tier, Threaded discussion logs for human review and approval
-```
@@ -1,29 +0,0 @@
-{
-  "name": "three-tier-evaluation-pipeline",
-  "version": "1.0.0",
-  "goal": "Run tasks through three evaluation tiers (Run, Trace, Thread) to produce comprehensive reports with human-in-the-loop validation",
-  "inputs": [
-    "query/input text for the task",
-    "search results (for trace tier evaluation)",
-    "evaluation criteria and thresholds"
-  ],
-  "steps": [
-    "Step 1: Execute the main task using the Run tier of the evaluation pipeline (agentkit/runtime/LangGraph engine) to generate initial outputs and results",
-    "Step 2: Run the Trace tier where an LLM-as-Judge evaluates the output against defined criteria, generating detailed analysis and scoring",
-    "Step 3: Execute the Thread tier which facilitates human-in-the-loop discussion, approval, and iterative refinement of the output"
-  ],
-  "outputs": [
-    "Final consolidated report combining results from all three tiers",
-    "Detailed scores and metrics per tier",
-    "Threaded discussion logs for human review and approval"
-  ],
-  "failure_modes": [
-    "If the Run tier fails (e.g., code execution error), the pipeline can retry but may produce incomplete outputs",
-    "If the Trace tier LLM-as-Judge produces low-quality evaluations, the Thread tier may need additional human intervention",
-    "Threshold mismatches between tiers could cause the pipeline to exit early or require manual adjustment"
-  ],
-  "confidence": 0.95,
-  "explanation": "The AgentKit repository contains a production-ready three-tier evaluation pipeline (Run \u2192 Trace \u2192 Thread) that can be adapted to any task requiring multi-stage validation. This workflow uses LangGraph for orchestration and LangChain for tool integration, making it portable across different agent engineering scenarios. The pattern is reusable because it separates concerns into distinct stages with clear inputs/outputs, allowing teams to plug in different evaluation criteria or human reviewers as needed.",
-  "source_repo": "https://github.com/itszhaoziyan-n/AgentKit.git",
-  "score": 1.0
-}
@@ -1,9 +0,0 @@
-# Tests: three-tier-evaluation-pipeline
-
-## Test Checklist
-
- [ ] Workflow has at least 3 steps
- [ ] All inputs are defined
- [ ] All outputs are defined
- [ ] Failure modes are documented
- [ ] Skill can be loaded without errors