ibm-watsonx-orchestrate-mcp-server 1.13.0b0__py3-none-any.whl

ibm_watsonx_orchestrate_mcp_server/src/knowledge_bases/mcp_tools.py

@@ -0,0 +1,66 @@
+from typing import List, Literal, Optional
+from ibm_watsonx_orchestrate.cli.commands.knowledge_bases.knowledge_bases_controller import KnowledgeBaseController
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+
+def list_knowledge_bases(verbose:bool=False)-> List[dict]:
+    """
+    Lists the avalible knowledge bases available on the watsonx Orchestrate platform.
+    """
+    kbc: KnowledgeBaseController = KnowledgeBaseController()
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    knowledge_bases: List[dict] = silent_call(fn=kbc.list_knowledge_bases, verbose=verbose, format=format)
+    return knowledge_bases
+
+def import_knowledge_bases(file_path: str, app_id: Optional[str] = None) -> str:
+    """
+    Import a knowledge base from a spec file into the watsonx Orchestrate platform.
+
+    Args:
+        file_path (str): The path to the knowledge base spec file.
+        app_id (str, optional): The app id of a connection in the watsonx Orchestrate platform. Used to authenticate to external knowledge base systems like Milvus or Elastic Search. Defaults to None.
+
+    Returns:
+        str: A success message indicating the knowledge base was imported successfully.
+    """
+    working_directory_file_path: str = get_working_directory_path(file_path)
+
+    kbc: KnowledgeBaseController = KnowledgeBaseController()
+    silent_call(fn=kbc.import_knowledge_base, file=working_directory_file_path, app_id=app_id)
+    return "Knowledge base imported successfully."
+
+def remove_knowledge_base(id:  Optional[str] = None, name: Optional[str] = None) -> str:
+    """
+    Remove a knowledge base from the watsonx Orchestrate platform.
+    Requires either a name or id to identify the knowledge base to remove. If both are provided, the id will be used.
+
+    Args:
+        id (str, optional): The id of the knowledge base to remove. Defaults to None.
+        name (str, optional): The name of the knowledge base to remove. Defaults to None.
+
+        Returns:
+    """
+    kbc: KnowledgeBaseController = KnowledgeBaseController()
+    silent_call(fn=kbc.remove_knowledge_base, id=id, name=name)
+    identifier: str | None = id if id else name
+    return f"Knowledge base '{identifier}' removed successfully."
+
+def check_knowledge_base_status(id:  Optional[str] = None, name: Optional[str] = None) -> dict:
+    """
+    Check the status of a knowledge base in the watsonx Orchestrate platform.
+    This will show if the knowledge base has been indexed and if ready to be used.
+    Requires either a name or id to identify the knowledge base to check. If both are provided, the id will be used.
+
+    Args:
+        id (str, optional): The id of the knowledge base to check. Defaults to None.
+        name (str, optional): The name of the knowledge base to check. Defaults to None.
+    
+    Returns:
+        str: The status of the knowledge base.
+    """
+    kbc: KnowledgeBaseController = KnowledgeBaseController()
+    knowledge_base: dict = silent_call(fn=kbc.knowledge_base_status, id=id, name=name, format=ListFormats.JSON)
+    return knowledge_base
+
+__tools__ = [list_knowledge_bases, import_knowledge_bases, remove_knowledge_base, check_knowledge_base_status]

ibm_watsonx_orchestrate_mcp_server/src/models/mcp_tools.py

@@ -0,0 +1,207 @@
+from typing import Any, List, Literal, Optional
+from ibm_watsonx_orchestrate.agent_builder.model_policies.types import ModelPolicy
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+from ibm_watsonx_orchestrate_mcp_server.src.connections.helpers import ConnectionsHelper
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+from ibm_watsonx_orchestrate.agent_builder.models.types import ModelListEntry, VirtualModel, ListVirtualModel, ModelType
+from ibm_watsonx_orchestrate.cli.commands.models.models_controller import ModelsController
+from ibm_watsonx_orchestrate_mcp_server.src.models.types import CreateModelOptions, CreateModelPolicyOptions
+
+def __format_model_name(model_name: str) -> str:
+    return f"virtual-model/{model_name}" if not model_name.startswith("virtual-model/") else model_name
+
+def __format_model_policy_name(policy_name: str) -> str:
+    return f"virtual-policy/{policy_name}" if not policy_name.startswith("virtual-policy/") else policy_name
+
+def list_models() -> List[ModelListEntry]:
+    """
+    List all models and model policies in the watsonx Orchestrate platform.
+    Custom models will being with the prefix "virtual-model/".
+    Model policies will being with the prefix "virtual-policy/"
+
+    Returns:
+        List[ModelListEntry]: A list of models configurations.
+    """
+    mc: ModelsController = ModelsController()
+    models = silent_call(fn=mc.list_models, format=ListFormats.JSON)
+    return models
+
+def import_model(file_path: str, app_id: Optional[str]=None) -> List[VirtualModel]:
+    """
+    Import a model in the watsonx Orchestrate platform
+    Args:
+        file_path (str): Path to the model file.
+        app_id (str, optional): The app_id of a key_value connection containing secrets for model authentication such as api_key. These values are merged with the provider_config field in the spec and provide a secure way of passing secret data to the model config. Defaults to None.
+    Returns:
+        List[VirtualModel]: The response from the watsonx Orchestrate platform.
+    """
+    working_directory_path = get_working_directory_path(file_path)
+    mc: ModelsController = ModelsController()
+    models = silent_call(
+        fn=mc.import_model,
+        file=working_directory_path,
+        app_id=app_id
+    )
+    for model in models:
+        silent_call(
+            fn=mc.publish_or_update_models,
+            model=model,
+        )
+    return models
+
+def create_or_update_model(options: CreateModelOptions) -> VirtualModel:
+    """
+    Create a model in the watsonx Orchestrate platform. If a model with the same name already exists update it instead.
+    Args:
+        options (CreateModelOptions): The options for creating the model.
+    Returns:
+        VirtualModel: The created model.
+    """
+    mc: ModelsController = ModelsController()
+    models_client = silent_call(fn=mc.get_models_client)
+    existing_name: str = __format_model_name(options.name)
+    existing_models = silent_call(fn=models_client.get_draft_by_name, model_name=existing_name)
+    provider_config_dict: dict[str, Any] | None = options.provider_config.model_dump() if options.provider_config else None
+
+    existing_model_data: ListVirtualModel | None = None
+    if len(existing_models) == 1:
+        existing_model_data = existing_models[0]
+    elif len(existing_models) > 1:
+        raise Exception(f"Multiple models found with name {options.name}. Update is ambiguous. Please delete the duplicate and try again.")
+
+    if not existing_model_data:
+        model = silent_call(
+            fn=mc.create_model,
+            name=options.name,
+            description=options.description,
+            display_name=options.display_name,
+            provider_config_dict=provider_config_dict,
+            model_type=options.type,
+            app_id=options.app_id
+        )
+    else:
+        connections_helper: ConnectionsHelper = ConnectionsHelper()
+        existing_app_id: str | None = None
+        if existing_model_data.connection_id:
+            existing_app_id = connections_helper.get_app_id_by_connection_id(existing_model_data.connection_id)
+        existing_model_provider_config: dict[str, Any] | None = existing_model_data.provider_config.model_dump() if existing_model_data.provider_config else None
+        existing_model_type: str | Literal[ModelType.CHAT] = existing_model_data.model_type if existing_model_data.model_type else ModelType.CHAT
+        existing_model = silent_call(
+            fn=mc.create_model,
+            name=existing_model_data.name,
+            description=existing_model_data.description,
+            display_name=existing_model_data.display_name,
+            provider_config_dict=existing_model_provider_config,
+            model_type=existing_model_type,
+            app_id=existing_app_id
+        )
+
+        options.name = existing_name
+        
+        model = existing_model.model_copy(update=options.model_dump(exclude_unset=True))
+
+
+    silent_call(
+        fn=mc.publish_or_update_models,
+        model=model,
+    )
+    return model
+
+def remove_model(name: str) -> str:
+    """
+    Remove a model from the watsonx Orchestrate platform.
+
+    Args:
+        name (str): The name of the model to remove.
+
+    Returns:
+        str: A message indicating the success of the removal operation.
+    """
+    model_name: str = __format_model_name(model_name=name)
+    mc: ModelsController = ModelsController()
+    silent_call(fn=mc.remove_model, name=model_name)
+    return f"Successfully removed model '{model_name}'."
+
+def import_model_policy(file_path: str) -> List[ModelPolicy]:
+    """
+    Import a model policy from a file into the watsonx Orchestrate platform.
+
+    Args:
+        file_path (str): The path to the file containing the model policy.
+
+    Returns:
+        List[ModelPolicy]: A list of ModelPolicy objects representing the imported model policy.
+    """
+    working_directory_path = get_working_directory_path(file_path)
+    mc: ModelsController = ModelsController()
+    policies = silent_call(
+        fn=mc.import_model_policy,
+        file=working_directory_path
+    )
+    for policy in policies:
+        silent_call(
+            fn=mc.publish_or_update_model_policies,
+            policy=policy,
+        )
+    return policies
+
+def create_or_update_model_policy(options: CreateModelPolicyOptions) -> ModelPolicy:
+    """
+    Create or update a model policy in the watsonx Orchestrate platform. If a model policy with the name is found it will update else it will create a new one.
+    
+    Args:
+        options (CreateModelPolicyOptions): The options for creating or updating the model policy.
+
+    Returns:
+        ModelPolicy: The created or updated model policy.
+    """
+    mc: ModelsController = ModelsController()
+    model_policies_client = silent_call(fn=mc.get_model_policies_client)
+    existing_name: str = __format_model_policy_name(options.name)
+    existing_policies = silent_call(fn=model_policies_client.get_draft_by_name, policy_name=existing_name)
+
+    existing_policy: ModelPolicy | None = None
+    if len(existing_policies) == 1:
+        existing_policy = existing_policies[0]
+    elif len(existing_policies) > 1:
+        raise Exception(f"Multiple model policies found with name {options.name}. Update is ambiguous. Please delete the duplicate and try again.")
+
+    if not existing_policy:
+        model = silent_call(
+            fn=mc.create_model_policy,
+            name=options.name,
+            description=options.description,
+            display_name=options.display_name,
+            models=options.models,
+            strategy=options.strategy,
+            strategy_on_code=options.strategy_on_code,
+            retry_on_code=options.retry_on_code,
+            retry_attempts=options.retry_attempts
+        )
+    else:
+        model: ModelPolicy = existing_policy.model_copy(update=options.model_dump(exclude_unset=True))
+
+
+    silent_call(
+        fn=mc.publish_or_update_models,
+        model=model,
+    )
+    return model
+
+def remove_model_policy(name: str) -> str:
+    """
+    Remove a model policy from the watsonx Orchestrate platform
+
+    Args:
+        name (str): The name of the model policy to remove.
+
+    Returns:
+        str: A message indicating the success of the removal operation.
+    """
+    policy_name: str = __format_model_policy_name(policy_name=name)
+    mc: ModelsController = ModelsController()
+    silent_call(fn=mc.remove_policy, name=policy_name)
+    return f"Successfully removed model policy '{policy_name}'."
+
+__tools__ = [list_models, import_model, create_or_update_model, remove_model, import_model_policy, create_or_update_model_policy, remove_model_policy]

ibm_watsonx_orchestrate_mcp_server/src/models/types.py

@@ -0,0 +1,60 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from ibm_watsonx_orchestrate.agent_builder.models.types import ProviderConfig, ModelType
+from ibm_watsonx_orchestrate.agent_builder.model_policies.types import  ModelPolicyStrategyMode
+
+class CreateModelOptions(BaseModel):
+    name: str = Field(
+        description="Name of the model you wish to create. Must be in the format '<provider>/<model_name>'"
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="Description of the model you wish to create."
+    )
+    display_name: Optional[str] = Field(
+        default=None,
+        description="A human readable name for the model."
+    )
+    provider_config: Optional[ProviderConfig] = Field(
+        default=None,
+        description="Provider specific configuration for the model such as connection details or cloud resource identifiers."
+    )
+    app_id: Optional[str] = Field(
+        default=None,
+        description="The app_id of a key_value connection containing secrets for model authentication such as api_key. These values are merged with the provider_config and provide a secure way of passing secret data to the model config"
+    )
+    type: ModelType = Field(
+        default=ModelType.CHAT,
+        description="The type of model being created. Defaults to 'chat'"
+    )
+
+class CreateModelPolicyOptions(BaseModel):
+    name: str = Field(
+        description="Name of the model policy you wish to create."
+    )
+    description: Optional[str] = Field(
+        default=None,
+        description="Description of the model policy you wish to create."
+    )
+    display_name: Optional[str] = Field(
+        default=None,
+        description="A human readable display name for the model policy."
+    )
+    models: List[str] = Field(
+        description="List of models to be used by the policy."
+    )
+    strategy: ModelPolicyStrategyMode = Field(
+        description="How the policy will handle model selection. 'fallback' will select the first model in the list and move down the list if that errors. 'loadbalance' will share request between all the models."
+    )
+    retry_attempts: Optional[int] = Field(
+        default=None,
+        description="Number of times a model will be retried before failing."
+    )
+    strategy_on_code: Optional[List[int]] = Field(
+        default=None,
+        description="List of HTTP status codes to envoke the strategy on. Primarily used by fallback to specify what HTTP codes trigger a different model to be called."
+    )
+    retry_on_code: Optional[List[int]] = Field(
+        default=None,
+        description="List of HTTP status codes that should trigger a retry."
+    )

ibm_watsonx_orchestrate_mcp_server/src/toolkits/mcp_tools.py

@@ -0,0 +1,67 @@
+from typing import List, Literal, Optional
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_command import import_toolkit as import_toolkit_command
+from ibm_watsonx_orchestrate.cli.commands.toolkit.toolkit_controller import ToolkitController
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+
+from ibm_watsonx_orchestrate_mcp_server.src.toolkits.types import ImportToolKitOptions
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+
+def list_toolkits(verbose:bool=False)-> List[dict]:
+    """
+    Lists the avalible toolkits (MCP Servers) available on the watsonx Orchestrate platform.
+
+    Args:
+        verbose (bool, optional): Return verbose information without processing. Should only be used for getting extra details. Defaults to False.
+    
+    Returns:
+        List[dict]: A list of dictionaries containing information about the toolkits available on the watsonx Orchestrate platform.
+    """
+    tc: ToolkitController = ToolkitController()
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    tools: List[dict] = silent_call(fn=tc.list_toolkits, verbose=verbose, format=format)
+    return tools
+
+def import_toolkit(options: ImportToolKitOptions) -> str:
+    """
+    Import a toolkit (MCP server) into the watsonx Orchestrate platform.
+
+    Args:
+        options (ImportToolKitOptions): The options required to import a toolkit into the watsonx Orchestrate platform
+    
+    Returns:
+        str: A success message indicating the toolkit was successfully imported
+    """
+    working_directory_package_root: str | None = get_working_directory_path(options.package_root) if options.package_root else None
+    tools: Optional[str] = ",".join(options.tools) if options.tools else None
+    silent_call(
+        fn=import_toolkit_command, 
+        kind=options.kind,
+        name=options.name,
+        description=options.description,
+        package=options.package,
+        package_root=working_directory_package_root,
+        language=options.language,
+        command=options.command,
+        url=options.url,
+        transport=options.transport,
+        tools=tools,
+        app_id=options.app_id
+    )
+    return f"The toolking {options.name} has been imported successfully"
+
+def remove_toolkit(name: str)-> str:
+    """
+    Remove a toolkit (MCP server) from the watsonx Orchestrate platform.
+
+    Args:
+        name (str): The name of the toolkit to remove
+    
+    Returns:
+        str: A success message indicating the toolkit was successfully removed
+    """
+    tc: ToolkitController = ToolkitController()
+    silent_call(fn=tc.remove_toolkit, name=name)
+    return f"The toolkit {name} has been removed successfully"
+
+__tools__ = [list_toolkits, import_toolkit, remove_toolkit]

ibm_watsonx_orchestrate_mcp_server/src/toolkits/types.py

@@ -0,0 +1,19 @@
+from ibm_watsonx_orchestrate.agent_builder.toolkits.types import Language, ToolkitKind, ToolkitTransportKind
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class ImportToolKitOptions(BaseModel):
+    """
+    Options for importing a toolkit (MCP server) into the watsonx Orchestrate platform.
+    """
+    kind: ToolkitKind = Field(description="Kind of toolkit. Allowed values ['mcp']")
+    name: str = Field(description="Arbitrary name to identify the toolkit. It should be unique from other toolkits")
+    description: str = Field(description ="A description if the toolkit and its contents")
+    package: Optional[str] = Field(default=None, description="Name of the package in the npm or pypi repository. Used when pulling the MCP server files from a public repository. Cannot be used with the 'package-root' option")
+    package_root: Optional[str] = Field(default=None, description="File path to the root of the MCP Server or a zip file with the MCP Server. Used when uploading the MCP server files from the local machine. Cannot be used with the 'package'")
+    language: Optional[Language] = Field(default=None, description="The language of the toolkit. Used to infer a default 'command' when using the package option (For node its 'npx -y <package>' and for python its 'python -m <package>')")
+    command: Optional[str] = Field(default=None, description="Command used to start the MCP server")
+    url: Optional[str] = Field(default=None, description="URL to the MCP server. Used when using a remote MCP server via transports 'streamable_http' or 'sse'")
+    transport: Optional[ToolkitTransportKind] = Field(default=None, description="Used for remote MCP server. Valid options are 'streamable_http' or 'sse'. For 'stdio' leave this as null and specify either the 'package' or 'package-root' options")
+    tools: Optional[List[str]] = Field(default=["*"], description="List of tools to be used with the MCP server. '[*]' means all tools on the server will be imported. Additionally, null will also cause all tools to be imported.")
+    app_id: Optional[List[str]] = Field(default=None, description="List of app ids related to connections in the Orchestrate platform. For 'stdio'/local these should be key_value connections which will be exposed as env vars for the server. For remote MCP servers these will be used to authenticate requests and can be other kinds like basic or api key auth.")

ibm_watsonx_orchestrate_mcp_server/src/tools/mcp_tools.py

@@ -0,0 +1,155 @@
+from typing import  Literal
+from typing_extensions import List, Optional
+from pathlib import Path
+
+from tempfile import TemporaryDirectory
+from ibm_watsonx_orchestrate.agent_builder.tools import BaseTool
+from ibm_watsonx_orchestrate.cli.commands.tools.tools_controller import ToolKind, ToolsController
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+
+# Pseudo-resources
+def get_tool_template() -> str:
+    """
+    Get a string template with placeholders for the format of a watsonx Orchestrate tool.
+
+    Returns:
+        str: The structure required for a watsonx Orchestrate python tool. Template placeholders are marked in angled brackets '<>'.
+    """
+    return """
+from ibm_watsonx_orchestrate.agent_builder.tools import tool
+<Any additional imports>
+
+@tool(
+    expected_credentials = [
+        {"app_id": <An identifier used to reference the credentials>, "type": <A 'ConnectionType' or list of 'ConnectionType' specifying what type of credentials the tool supports>}
+    ] # expected_credentials is optional and is only needed when tools make use of credentials/connections
+)
+def <tool_name>(<arguments with type hints>) -> <return type hint>:
+    <python code>
+"""
+
+def create_tool(content: str, app_id: Optional[str] = None, requirements_filepath: Optional[str] = None) -> BaseTool:
+    """
+    Create a watsonx Orchestrate tool from a string of python code. The string should follow the pattern outlined in the template that can be gotten from the tool 'get_tool_template'.
+
+    Args:
+        content (str): Valid python code that conforms to the schema found using the tool 'get_tool_template'
+        app_id (str | None): An optional app_id which relates an Orchestrate connection object to the tool. Used to provide credentials for the tool to make use of. Should match the app id of the expect_credentials object.
+        requirements_filepath (str | None): An optional path to a requirements.txt file for python tools to allow for external packages avalible on pypi to be used.
+
+    Returns:
+        str: The constructed tool.
+    """
+    working_directory = get_working_directory_path(".")
+    working_directory_requirements_path: str | None = get_working_directory_path(requirements_filepath) if requirements_filepath else None
+
+    with TemporaryDirectory(dir=working_directory) as tmp_dir:
+        tool_file_path = Path(tmp_dir) / "temp_tool.py"
+        tool_file_path.write_text(content)
+        
+        tc: ToolsController = ToolsController(tool_kind=ToolKind.python, file=str(tool_file_path), requirements_file=working_directory_requirements_path)
+        tools: List[BaseTool] = silent_call(
+            fn=tc.import_tool,
+            kind=ToolKind.python,
+            file=str(tool_file_path),
+            app_id=app_id,
+            requirements_file=working_directory_requirements_path,
+            package_root=None,
+        )
+        tools_list: list[BaseTool] = list(tools)
+        silent_call(tc.publish_or_update_tools, tools_list, package_root=None)
+    
+    if len(tools_list):
+        return tools_list[0]
+    else:
+        raise Exception("No valid tools created")
+        
+
+def import_tool(kind: ToolKind, path: str, app_id: Optional[str] = None, requirements_filepath: Optional[str] = None, package_root: Optional[str] = None) -> List[BaseTool]:
+    """
+    Import a tool into the watsonx Orchestrate platform
+
+    Args:
+        kind (ToolKind): The kind of tool to import. Valid options are ['python' | 'openapi' | 'flow']
+        path (str): The path to the tool definition file.
+        app_id (str | None): An optional app_id which relates an Orchestrate connection object to the tool. Used to provide credentials for the tool to make use of.
+        requirements_filepath (str | None): An optional path to a requirements.txt file for python tools.
+        package_root (str | None): An optional path to a packageroot for python tools with multiple files.
+    
+    Returns:
+        List[BaseTool]: The newly created tools.
+    """
+
+    working_directory_path: str = get_working_directory_path(path)
+    working_directory_requirements_path: str | None = get_working_directory_path(requirements_filepath) if requirements_filepath else None
+    working_directory_package_root: str | None = get_working_directory_path(package_root) if package_root else None
+
+    tc: ToolsController = ToolsController(tool_kind=kind, file=working_directory_path, requirements_file=working_directory_requirements_path)
+    tools: List[BaseTool] = silent_call(
+        fn=tc.import_tool,
+        kind=kind,
+        file=working_directory_path,
+        app_id=app_id,
+        requirements_file=working_directory_requirements_path,
+        package_root=working_directory_package_root,
+    )
+    tools_list: list[BaseTool] = list(tools)
+    silent_call(tc.publish_or_update_tools, tools_list, package_root=working_directory_package_root)
+    return tools_list
+
+def list_tools(verbose:bool=False)-> List[dict]:
+    """
+    Lists the tools available on the watsonx Orchestrate platform.
+
+    Args:
+        verbose (bool, optional): Return verbose information without processing. Should only be used for getting extra details. Defaults to False.
+    
+    Returns:
+        List[dict]: A list of dictionaries containing information about the tools available on the watsonx Orchestrate platform.
+    """
+    tc: ToolsController = ToolsController()
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    tools: List[dict] = silent_call(fn=tc.list_tools, verbose=verbose, format=format)
+    return tools
+
+
+def remove_tool(name: str) -> str:
+    """
+    Removes a tool from the watsonx Orchestrate platform.
+
+    Args:
+        name (str): The name of the tool to remove.
+    
+    Returns:
+        str: A message indicating the success of the removal
+    """
+
+    tc: ToolsController = ToolsController()
+    silent_call(
+        fn=tc.remove_tool,
+        name=name
+    )
+
+    return f"The tool {name} has been removed successfully"
+
+def export_tool(name: str, output_file_path: str) -> str:
+    """
+    Exports a tool from the watsonx Orchestrate platform.
+
+    Args:
+        name (str): The name of the tool to export
+        output_file_path (str): The path to where the tool should create the output file. Should have a .zip extension
+    """
+    working_directory_output_path: str = get_working_directory_path(output_file_path)
+    tc: ToolsController = ToolsController()
+    silent_call(
+        fn=tc.export_tool,
+        name=name,
+        output_path=working_directory_output_path
+    )
+    return f"The tool {name} has been exported successfully"
+
+__tools__ = [get_tool_template, import_tool, list_tools, remove_tool, export_tool, create_tool]

ibm_watsonx_orchestrate_mcp_server/src/version_checker.py

@@ -0,0 +1,7 @@
+from ibm_watsonx_orchestrate_mcp_server.utils.config import config
+
+def check_version() -> str:
+    """
+    Check the version of the Orchestrate MCP server
+    """
+    return f"{config.server_name} v{config.version}"

ibm_watsonx_orchestrate_mcp_server/src/voice_configurations/mcp_tools.py

@@ -0,0 +1,52 @@
+from typing import Any, List, Literal
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations import VoiceConfiguration
+from ibm_watsonx_orchestrate.agent_builder.voice_configurations.types import VoiceConfigurationListEntry
+from ibm_watsonx_orchestrate.cli.commands.voice_configurations.voice_configurations_controller import VoiceConfigurationsController
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+
+def list_voice_configs(verbose: bool = False) -> List[VoiceConfigurationListEntry] | List[dict[str, Any]]:
+    """
+    List voice configurations in the watsonx Orchestrate platform
+
+    Args:
+        verbose (bool, optional):  Return verbose information without processing. Should only be used for getting extra details. Defaults to False.
+    
+    Returns:
+        List[VoiceConfigurationListEntry]: A list of voice configurations.
+    """
+    vcc: VoiceConfigurationsController = VoiceConfigurationsController()
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    voice_configs = silent_call(fn=vcc.list_voice_configs, format=format, verbose=verbose)
+    return voice_configs
+
+def import_voice_config(file_path: str) -> VoiceConfiguration:
+    """
+    Imports voice configurations from a spec file into the watsonx Orchestrate platform.
+
+    Args:
+        file_path (str): The path to the voice configuration spec file.
+
+    Returns:
+        VoiceConfiguration: The voice configuration imported from the spec file.
+    """
+    working_directory_file_path: str = get_working_directory_path(file_path)
+    vcc: VoiceConfigurationsController = VoiceConfigurationsController()
+    voice_config = silent_call(fn=vcc.import_voice_config, file=working_directory_file_path)
+    silent_call(fn=vcc.publish_or_update_voice_config, voice_config=voice_config)
+    return voice_config
+
+def remove_voice_config(voice_config_name: str) -> str:
+    """
+    Removes a voice configuration from the watsonx Orchestrate platform.
+    Args:
+        voice_config_name (str): The name of the voice configuration to be removed. 
+    Returns:
+        str: A success message indicating the voice configuration was removed successfully.
+    """
+    vcc: VoiceConfigurationsController = VoiceConfigurationsController()
+    silent_call(fn=vcc.remove_voice_config_by_name, voice_config_name=voice_config_name)
+    return f"Voice configuration '{voice_config_name}' removed successfully." 
+
+__tools__ = [list_voice_configs, import_voice_config, remove_voice_config]