Add skill loading support to generic agent

This commit introduces comprehensive skill loading functionality to the generic agent:

Core Features:
- Added SKILL_FOLDERS configuration to load custom skills from specified directories
- Implemented load_skills_content() function to read skill files (SKILL.md, *.py, *.md)
- Enhanced system prompt to include loaded skill descriptions and capabilities
- Updated agent card to display available skills alongside MCP servers

Error Handling:
- Graceful degradation when MCP servers are unavailable
- Warning messages instead of failures for missing skill folders
- Continues operation with partial skill loading if some skills fail

Testing:
- Added comprehensive test suite in tests/ directory
- Includes test_skill_loading.py for full integration tests
- Includes test_skill_loading_simple.py for basic functionality tests
- Added run_skill_test.sh script for easy test execution
- Created tests/README.md with testing documentation

Documentation:
- Updated README.md with skill loading information
- Added testing section with quick start guide
- Documented SKILL_FOLDERS environment variable

Code Quality:
- Fixed trailing whitespace and newline issues in multiple files
- Added proper logging throughout skill loading process
- Improved error messages for better debugging

Signed-off-by: Eran Raichstein <eranra@il.ibm.com>

Author: eranra

a2a/generic_agent/Dockerfile

@@ -11,4 +11,4 @@ ENV PRODUCTION_MODE=True \
 RUN chown -R 1001:1001 /app
 USER 1001
 
-CMD ["uv", "run", "--no-sync", "server"]
+CMD ["uv", "run", "--no-sync", "server"]

a2a/generic_agent/README.md

@@ -9,14 +9,26 @@ A flexible A2A agent that can be configured with multiple MCP servers to provide
 - **Multi-MCP Support**: Connect to multiple MCP servers simultaneously
 - **Dynamic Tool Loading**: Automatically discovers and uses tools from connected MCP servers
 - **LLM Agnostic**: Works with any OpenAI-compatible API (Ollama, OpenAI, etc.)
+- **Skill Loading**: Load custom skills to enhance agent capabilities
 - **A2A Protocol**: Full integration with A2A server for task management and streaming
 
+## Testing
+
+To test the agent's skill loading functionality, see the [tests directory](./tests/README.md).
+
+Quick start:
+```bash
+cd tests
+./run_skill_test.sh
+```
+
 ### Environment Variables
 
 | Variable | Description | Default |
 |----------|-------------|---------|
 | `MCP_URLS` | Comma-separated list of MCP server URLs | `http://localhost:8000/mcp` |
 | `MCP_TRANSPORT` | Transport protocol for MCP | `streamable_http` |
+| `SKILL_FOLDERS` | Comma-separated list of skill folder paths | `/app/skills/` |
 | `LLM_MODEL` | Model name to use | `llama3.2:3b-instruct-fp16` |
 | `LLM_API_BASE` | Base URL for LLM API | `http://localhost:11434/v1` |
 | `LLM_API_KEY` | API key for LLM service | `dummy` |
@@ -40,7 +52,7 @@ Once deployed, the agent can handle requests like:
 "Find me flights from SFO to TPE for November 22, 2025."
 ```
 
-The agent automatically selects the appropriate tool from connected MCP servers and returns formatted results. 
+The agent automatically selects the appropriate tool from connected MCP servers and returns formatted results.
 
 ## Running in Kagenti
 
@@ -49,4 +61,4 @@ When deploying in the Kagenti UI:
 1. Import your intended tools using the `Import New Tools` section.
 2. In the `Import New Agent` section, follow the given prompts and configure these environmental variables:
   - Choose the `ollama` or `openai` environmental variable set
-  - Create a new variable, `MCP_URLS`, and add your list of MCP server URLs separated with commas.
+  - Create a new variable, `MCP_URLS`, and add your list of MCP server URLs separated with commas.

a2a/generic_agent/pyproject.toml

@@ -24,4 +24,4 @@ server = "generic_agent.agent:run"
 
 [build-system]
 requires = ["hatchling"]
-build-backend = "hatchling.build"
+build-backend = "hatchling.build"

a2a/generic_agent/src/generic_agent/agent.py

@@ -15,7 +15,7 @@
 from a2a.types import AgentCapabilities, AgentCard, AgentSkill, TaskState, TextPart
 from a2a.utils import new_agent_text_message, new_task
 from generic_agent.config import Configuration
-from generic_agent.graph import get_graph, get_mcp_server_names, get_mcpclient
+from generic_agent.graph import get_graph, get_mcp_server_names, get_mcpclient, get_skill_folder_paths
 
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
@@ -31,23 +31,36 @@ def get_agent_card(host: str, port: int) -> AgentCard:
     except Exception as e:
         logger.warning(f"Failed to get MCP server names: {e}")
         mcp_names = []
+
+    try:
+        skill_folder_paths = get_skill_folder_paths()
+        # Extract skill names from folder paths (last component of path)
+        skill_names = [path.rstrip("/").split("/")[-1] for path in skill_folder_paths if path]
+    except Exception as e:
+        logger.warning(f"Failed to get skill folder paths: {e}")
+        skill_names = []
+
     mcp_section = ""
     if mcp_names:
         mcp_section = "\n\nConnected MCP Servers:\n" + "\n".join(f"- {name}" for name in mcp_names)
 
+    skills_section = ""
+    if skill_names:
+        skills_section = "\n\nAvailable Skills:\n" + "\n".join(f"- {name}" for name in skill_names)
+
     capabilities = AgentCapabilities(streaming=True)
     skill = AgentSkill(
         id="generic_agent",
         name="Generic Agent",
         description="**Generic Assistant** – Multi-purpose assistant for different tasks based on different MCP tools.",
-        tags=mcp_names,
+        tags=mcp_names + skill_names,
         examples=[],
     )
     return AgentCard(
         name="Generic Agent",
         description=dedent(
             f"""\
-            This agent provides assistance for various tasks using different MCP tools.{mcp_section}
+            This agent provides assistance for various tasks using different MCP tools.{mcp_section}{skills_section}
             """,
         ),
         # Allow env var AGENT_ENDPOINT to override the URL in the agent card
@@ -133,25 +146,30 @@ async def execute(self, context: RequestContext, event_queue: EventQueue):
 
         try:
             output = None
-            # Test MCP connection first
+            # Initialize MCP client with error handling
             logger.info(f"Attempting to connect to MCP server(s) at: {config.MCP_URLS}")
 
             mcpclient = get_mcpclient()
 
             # Try to get tools to verify connection
             try:
                 tools = await mcpclient.get_tools()
-                logger.info(
-                    f"Successfully connected to MCP server(s). Available tools: {[tool.name for tool in tools]}"
-                )
+                if tools:
+                    logger.info(
+                        f"Successfully connected to MCP server(s). Available tools: {[tool.name for tool in tools]}"
+                    )
+                else:
+                    logger.warning("No MCP tools available, but agent will continue")
             except Exception as tool_error:
-                logger.error(f"Failed to connect to MCP server(s): {tool_error}")
+                logger.warning(
+                    f"Failed to connect to MCP server(s): {tool_error}. Agent will continue without MCP tools."
+                )
                 await event_emitter.emit_event(
-                    f"Error: Cannot connect to MCP server(s) at {config.MCP_URLS}. Please ensure the MCP server(s) are running. Error: {tool_error}",
-                    failed=True,
+                    "⚠️ Warning: Cannot connect to MCP server(s). Agent will continue with limited capabilities.",
+                    final=False,
                 )
-                return
 
+            # Create graph (will work even without MCP tools)
             graph = await get_graph(mcpclient)
             async for event in graph.astream(input, stream_mode="updates"):
                 await event_emitter.emit_event(

a2a/generic_agent/src/generic_agent/config.py

@@ -9,3 +9,4 @@ class Configuration(BaseSettings):
     MCP_TRANSPORT: str = "streamable_http"
     MAX_EVENT_DISPLAY_LENGTH: int = 256
     AGENT_VERSION: str = "1.0.0"
+    SKILL_FOLDERS: str = "/app/skills/"

a2a/generic_agent/src/generic_agent/graph.py

@@ -1,4 +1,6 @@
+import logging
 from functools import lru_cache
+from pathlib import Path
 from typing import List
 
 from langchain_core.messages import AIMessage, SystemMessage
@@ -10,6 +12,7 @@
 from generic_agent.config import Configuration
 
 config = Configuration()
+logger = logging.getLogger(__name__)
 
 
 # Extend MessagesState to include a final answer
@@ -25,16 +28,33 @@ def _get_mcp_urls() -> List[str]:
 
 @lru_cache(maxsize=1)
 def get_mcpclient() -> MultiServerMCPClient:
+    """
+    Create MCP client with error handling.
+
+    If individual MCP servers fail to connect, logs warnings but continues
+    with available servers.
+
+    Returns:
+        MultiServerMCPClient instance (may have empty configs if all servers fail)
+    """
     urls = _get_mcp_urls()
 
     client_configs = {}
     transport = config.MCP_TRANSPORT
 
     for i, url in enumerate(urls, 1):
-        client_configs[f"mcp{i}"] = {
-            "url": url,
-            "transport": transport,
-        }
+        try:
+            client_configs[f"mcp{i}"] = {
+                "url": url,
+                "transport": transport,
+            }
+        except Exception as e:
+            logger.warning(f"Failed to configure MCP server {url}: {e}")
+            continue
+
+    if not client_configs:
+        logger.warning("No MCP servers configured successfully. Agent will work without MCP tools.")
+
     return MultiServerMCPClient(client_configs)
 
 
@@ -64,6 +84,126 @@ def get_mcp_server_names() -> List[str]:
     return mcp_names
 
 
+def get_skill_folder_paths() -> List[str]:
+    """
+    Extract skill folder paths from the SKILL_FOLDERS configuration.
+
+    The SKILL_FOLDERS field contains comma-separated folder paths.
+    Example: "/app/skills/pdf,/app/skills/skill-creator" -> ["/app/skills/pdf", "/app/skills/skill-creator"]
+
+    Returns:
+        List of skill folder paths
+    """
+    folders_str = config.SKILL_FOLDERS
+    if not folders_str or not folders_str.strip():
+        return []
+
+    folder_paths = []
+    for folder in folders_str.split(","):
+        folder = folder.strip()
+        if folder:
+            folder_paths.append(folder)
+
+    return folder_paths
+
+
+def load_skills_content() -> str:
+    """
+    Load skill content from skill folders with error handling.
+
+    Reads all relevant files from each skill folder:
+    - SKILL.md: Main skill description and instructions
+    - *.py: Python scripts and tools
+    - *.md: Additional documentation files
+
+    If individual skills fail to load, logs warnings but continues with other skills.
+
+    Returns:
+        Combined skill content as a string, or empty string if no skills found
+    """
+    skill_folders = get_skill_folder_paths()
+    if not skill_folders:
+        return ""
+
+    skills_content = []
+    failed_skills = []
+
+    for folder_path in skill_folders:
+        try:
+            skill_path = Path(folder_path)
+            if not skill_path.exists() or not skill_path.is_dir():
+                logger.warning(f"Skill folder does not exist or is not a directory: {folder_path}")
+                failed_skills.append(skill_path.name if skill_path else folder_path)
+                continue
+
+            skill_name = skill_path.name
+            skill_parts = [f"### Skill: {skill_name}\n"]
+
+            # Load SKILL.md first (main description)
+            skill_md_path = skill_path / "SKILL.md"
+            if skill_md_path.exists() and skill_md_path.is_file():
+                try:
+                    with open(skill_md_path, "r", encoding="utf-8") as f:
+                        content = f.read().strip()
+                        if content:
+                            skill_parts.append(f"#### Main Description\n\n{content}")
+                except Exception as e:
+                    logger.warning(f"Failed to read {skill_md_path}: {e}")
+
+            # Load Python scripts (these are tools/utilities the skill provides)
+            python_files = sorted(skill_path.rglob("*.py"))
+            if python_files:
+                scripts_content = []
+                for py_file in python_files:
+                    try:
+                        # Get relative path from skill folder
+                        rel_path = py_file.relative_to(skill_path)
+                        with open(py_file, "r", encoding="utf-8") as f:
+                            code = f.read().strip()
+                            if code:
+                                scripts_content.append(f"**File: {rel_path}**\n```python\n{code}\n```")
+                    except Exception as e:
+                        logger.warning(f"Failed to read {py_file}: {e}")
+
+                if scripts_content:
+                    skill_parts.append("#### Available Scripts\n\n" + "\n\n".join(scripts_content))
+
+            # Load additional markdown files (documentation, examples, etc.)
+            md_files = sorted([f for f in skill_path.rglob("*.md") if f.name != "SKILL.md"])
+            if md_files:
+                docs_content = []
+                for md_file in md_files:
+                    try:
+                        rel_path = md_file.relative_to(skill_path)
+                        with open(md_file, "r", encoding="utf-8") as f:
+                            content = f.read().strip()
+                            if content:
+                                docs_content.append(f"**{rel_path}**\n\n{content}")
+                    except Exception as e:
+                        logger.warning(f"Failed to read {md_file}: {e}")
+
+                if docs_content:
+                    skill_parts.append("#### Additional Documentation\n\n" + "\n\n".join(docs_content))
+
+            if len(skill_parts) > 1:  # More than just the header
+                skills_content.append("\n\n".join(skill_parts))
+        except Exception as e:
+            logger.warning(f"Failed to load skill from {folder_path}: {e}")
+            failed_skills.append(Path(folder_path).name)
+            continue
+
+    if failed_skills:
+        logger.warning(f"Failed to load {len(failed_skills)} skill(s): {', '.join(failed_skills)}")
+
+    if skills_content:
+        loaded_count = len(skills_content)
+        logger.info(f"Successfully loaded {loaded_count} skill(s)")
+        return "\n\n" + "\n\n---\n\n".join(skills_content)
+
+    logger.info("No skills loaded")
+    return ""
+
+
 async def get_graph(client: MultiServerMCPClient) -> StateGraph:
     llm = ChatOpenAI(
         model=config.LLM_MODEL,
@@ -72,14 +212,31 @@ async def get_graph(client: MultiServerMCPClient) -> StateGraph:
         temperature=0,
     )
 
-    # Get tools asynchronously
-    tools = await client.get_tools()
-    llm_with_tools = llm.bind_tools(tools)
+    # Get tools asynchronously with error handling
+    try:
+        tools = await client.get_tools()
+        if tools:
+            logger.info(f"Successfully loaded {len(tools)} MCP tool(s)")
+        else:
+            logger.warning("No MCP tools available")
+        llm_with_tools = llm.bind_tools(tools)
+    except Exception as e:
+        logger.warning(f"Failed to load MCP tools: {e}. Agent will work without MCP tools.")
+        tools = []
+        llm_with_tools = llm
 
-    # System message
-    sys_msg = SystemMessage(
-        content="You are the **Generic Assistant**, a multi-purpose, tool-based expert. Your primary directive is to fulfill user requests by effectively utilizing the available **MCP tools**. You will select the most appropriate tool(s) based on the user's need (e.g., weather, calculations, data retrieval) and strictly adhere to their output to generate your final answer. Be precise and concise."
-    )
+    # Load skills content if available
+    skills_content = load_skills_content()
+
+    # Build system message
+    base_instruction = "You are the **Generic Assistant**, a multi-purpose, tool-based expert. Your primary directive is to fulfill user requests by effectively utilizing the available **MCP tools**. You will select the most appropriate tool(s) based on the user's need (e.g., weather, calculations, data retrieval) and strictly adhere to their output to generate your final answer. Be precise and concise."
+
+    if skills_content:
+        system_content = f"{base_instruction}\n\n## Available Skills\n\nYou have access to the following specialized skills. Use them when the user's request matches the skill's capabilities:{skills_content}"
+    else:
+        system_content = base_instruction
+
+    sys_msg = SystemMessage(content=system_content)
 
     # Node
     def assistant(state: ExtendedMessagesState) -> ExtendedMessagesState: