From 8f3df89b9afd3796c764fa1206b0268acefcb41c Mon Sep 17 00:00:00 2001
From: Razvan Radulescu <43811028+h3xxit@users.noreply.github.com>
Date: Mon, 25 Aug 2025 18:57:17 +0200
Subject: [PATCH 1/2] Add API spec and update to 1.0
---
docs/api/core/utcp/data/auth.md | 85 +++++
.../data/auth_implementations/api_key_auth.md | 84 +++++
.../data/auth_implementations/basic_auth.md | 80 +++++
.../data/auth_implementations/oauth2_auth.md | 84 +++++
docs/api/core/utcp/data/call_template.md | 93 ++++++
.../utcp/data/register_manual_response.md | 33 ++
docs/api/core/utcp/data/tool.md | 200 ++++++++++++
docs/api/core/utcp/data/utcp_client_config.md | 128 ++++++++
docs/api/core/utcp/data/utcp_manual.md | 115 +++++++
docs/api/core/utcp/data/variable_loader.md | 101 ++++++
.../dot_env_variable_loader.md | 106 +++++++
.../utcp_serializer_validation_error.md | 18 ++
.../utcp_variable_not_found_exception.md | 45 +++
.../default_variable_substitutor.md | 132 ++++++++
.../implementations/in_mem_tool_repository.md | 219 +++++++++++++
.../core/utcp/implementations/tag_search.md | 96 ++++++
.../utcp_client_implementation.md | 180 +++++++++++
.../utcp/interfaces/communication_protocol.md | 152 +++++++++
.../interfaces/concurrent_tool_repository.md | 192 +++++++++++
docs/api/core/utcp/interfaces/serializer.md | 79 +++++
.../utcp/interfaces/tool_post_processor.md | 109 +++++++
.../utcp/interfaces/tool_search_strategy.md | 130 ++++++++
.../utcp/interfaces/variable_substitutor.md | 69 ++++
docs/api/core/utcp/plugins/discovery.md | 169 ++++++++++
docs/api/core/utcp/plugins/plugin_loader.md | 20 ++
docs/api/core/utcp/utcp_client.md | 184 +++++++++++
docs/api/index.md | 229 ++++++++++++++
.../cli/src/utcp_cli/cli_call_template.md | 62 ++++
.../utcp_cli/cli_communication_protocol.md | 97 ++++++
.../http/src/utcp_http/http_call_template.md | 71 +++++
.../utcp_http/http_communication_protocol.md | 108 +++++++
.../http/src/utcp_http/openapi_converter.md | 60 ++++
.../http/src/utcp_http/sse_call_template.md | 72 +++++
.../utcp_http/sse_communication_protocol.md | 46 +++
.../streamable_http_call_template.md | 74 +++++
.../streamable_http_communication_protocol.md | 46 +++
.../mcp/src/utcp_mcp/mcp_call_template.md | 85 +++++
.../utcp_mcp/mcp_communication_protocol.md | 41 +++
.../text/src/utcp_text/text_call_template.md | 58 ++++
.../utcp_text/text_communication_protocol.md | 44 +++
docs/for-tool-callers/for-tool-callers.md | 298 ------------------
docs/for-tool-callers/tool-repository.md | 86 -----
docs/for-tool-callers/tool-search-strategy.md | 84 -----
docs/for-tool-providers.md | 284 -----------------
docs/implementation.md | 153 ---------
docs/index.md | 71 +++--
docs/providers/cli.md | 186 -----------
docs/providers/graphql.md | 190 -----------
docs/providers/grpc.md | 128 --------
docs/providers/http-stream.md | 137 --------
docs/providers/http.md | 201 ------------
docs/providers/mcp.md | 166 ----------
docs/providers/providers.md | 136 --------
docs/providers/sse.md | 199 ------------
docs/providers/tcp.md | 117 -------
docs/providers/text.md | 152 ---------
docs/providers/udp.md | 126 --------
docs/providers/webrtc.md | 174 ----------
docs/providers/websocket.md | 190 -----------
docs/security.md | 30 +-
docs/utcp-vs-mcp.md | 10 +-
src/css/custom.css | 4 +
.../version-1.0/api/core/utcp/data/auth.md | 85 +++++
.../data/auth_implementations/api_key_auth.md | 84 +++++
.../data/auth_implementations/basic_auth.md | 80 +++++
.../data/auth_implementations/oauth2_auth.md | 84 +++++
.../api/core/utcp/data/call_template.md | 93 ++++++
.../utcp/data/register_manual_response.md | 33 ++
.../version-1.0/api/core/utcp/data/tool.md | 200 ++++++++++++
.../api/core/utcp/data/utcp_client_config.md | 128 ++++++++
.../api/core/utcp/data/utcp_manual.md | 115 +++++++
.../api/core/utcp/data/variable_loader.md | 101 ++++++
.../dot_env_variable_loader.md | 106 +++++++
.../utcp_serializer_validation_error.md | 18 ++
.../utcp_variable_not_found_exception.md | 45 +++
.../default_variable_substitutor.md | 132 ++++++++
.../implementations/in_mem_tool_repository.md | 219 +++++++++++++
.../core/utcp/implementations/tag_search.md | 96 ++++++
.../utcp_client_implementation.md | 180 +++++++++++
.../utcp/interfaces/communication_protocol.md | 152 +++++++++
.../interfaces/concurrent_tool_repository.md | 192 +++++++++++
.../api/core/utcp/interfaces/serializer.md | 79 +++++
.../utcp/interfaces/tool_post_processor.md | 109 +++++++
.../utcp/interfaces/tool_search_strategy.md | 130 ++++++++
.../utcp/interfaces/variable_substitutor.md | 69 ++++
.../api/core/utcp/plugins/discovery.md | 169 ++++++++++
.../api/core/utcp/plugins/plugin_loader.md | 20 ++
.../version-1.0/api/core/utcp/utcp_client.md | 184 +++++++++++
versioned_docs/version-1.0/api/index.md | 228 ++++++++++++++
.../cli/src/utcp_cli/cli_call_template.md | 62 ++++
.../utcp_cli/cli_communication_protocol.md | 97 ++++++
.../http/src/utcp_http/http_call_template.md | 71 +++++
.../utcp_http/http_communication_protocol.md | 108 +++++++
.../http/src/utcp_http/openapi_converter.md | 60 ++++
.../http/src/utcp_http/sse_call_template.md | 72 +++++
.../utcp_http/sse_communication_protocol.md | 46 +++
.../streamable_http_call_template.md | 74 +++++
.../streamable_http_communication_protocol.md | 46 +++
.../mcp/src/utcp_mcp/mcp_call_template.md | 85 +++++
.../utcp_mcp/mcp_communication_protocol.md | 41 +++
.../text/src/utcp_text/text_call_template.md | 58 ++++
.../utcp_text/text_communication_protocol.md | 44 +++
versioned_docs/version-1.0/index.md | 155 +++++++++
versioned_docs/version-1.0/security.md | 128 ++++++++
versioned_docs/version-1.0/utcp-vs-mcp.md | 102 ++++++
versioned_sidebars/version-1.0-sidebars.json | 8 +
versions.json | 1 +
107 files changed, 8445 insertions(+), 3062 deletions(-)
create mode 100644 docs/api/core/utcp/data/auth.md
create mode 100644 docs/api/core/utcp/data/auth_implementations/api_key_auth.md
create mode 100644 docs/api/core/utcp/data/auth_implementations/basic_auth.md
create mode 100644 docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
create mode 100644 docs/api/core/utcp/data/call_template.md
create mode 100644 docs/api/core/utcp/data/register_manual_response.md
create mode 100644 docs/api/core/utcp/data/tool.md
create mode 100644 docs/api/core/utcp/data/utcp_client_config.md
create mode 100644 docs/api/core/utcp/data/utcp_manual.md
create mode 100644 docs/api/core/utcp/data/variable_loader.md
create mode 100644 docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
create mode 100644 docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
create mode 100644 docs/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
create mode 100644 docs/api/core/utcp/implementations/default_variable_substitutor.md
create mode 100644 docs/api/core/utcp/implementations/in_mem_tool_repository.md
create mode 100644 docs/api/core/utcp/implementations/tag_search.md
create mode 100644 docs/api/core/utcp/implementations/utcp_client_implementation.md
create mode 100644 docs/api/core/utcp/interfaces/communication_protocol.md
create mode 100644 docs/api/core/utcp/interfaces/concurrent_tool_repository.md
create mode 100644 docs/api/core/utcp/interfaces/serializer.md
create mode 100644 docs/api/core/utcp/interfaces/tool_post_processor.md
create mode 100644 docs/api/core/utcp/interfaces/tool_search_strategy.md
create mode 100644 docs/api/core/utcp/interfaces/variable_substitutor.md
create mode 100644 docs/api/core/utcp/plugins/discovery.md
create mode 100644 docs/api/core/utcp/plugins/plugin_loader.md
create mode 100644 docs/api/core/utcp/utcp_client.md
create mode 100644 docs/api/index.md
create mode 100644 docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
create mode 100644 docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
create mode 100644 docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
create mode 100644 docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
delete mode 100644 docs/for-tool-callers/for-tool-callers.md
delete mode 100644 docs/for-tool-callers/tool-repository.md
delete mode 100644 docs/for-tool-callers/tool-search-strategy.md
delete mode 100644 docs/for-tool-providers.md
delete mode 100644 docs/implementation.md
delete mode 100644 docs/providers/cli.md
delete mode 100644 docs/providers/graphql.md
delete mode 100644 docs/providers/grpc.md
delete mode 100644 docs/providers/http-stream.md
delete mode 100644 docs/providers/http.md
delete mode 100644 docs/providers/mcp.md
delete mode 100644 docs/providers/providers.md
delete mode 100644 docs/providers/sse.md
delete mode 100644 docs/providers/tcp.md
delete mode 100644 docs/providers/text.md
delete mode 100644 docs/providers/udp.md
delete mode 100644 docs/providers/webrtc.md
delete mode 100644 docs/providers/websocket.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/auth.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/call_template.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/register_manual_response.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/tool.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/utcp_client_config.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/concurrent_tool_repository.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/serializer.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/tool_post_processor.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/tool_search_strategy.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/plugins/discovery.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
create mode 100644 versioned_docs/version-1.0/api/core/utcp/utcp_client.md
create mode 100644 versioned_docs/version-1.0/api/index.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
create mode 100644 versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
create mode 100644 versioned_docs/version-1.0/index.md
create mode 100644 versioned_docs/version-1.0/security.md
create mode 100644 versioned_docs/version-1.0/utcp-vs-mcp.md
create mode 100644 versioned_sidebars/version-1.0-sidebars.json
diff --git a/docs/api/core/utcp/data/auth.md b/docs/api/core/utcp/data/auth.md
new file mode 100644
index 0000000..67d971b
--- /dev/null
+++ b/docs/api/core/utcp/data/auth.md
@@ -0,0 +1,85 @@
+---
+title: auth
+sidebar_label: auth
+---
+
+# auth
+
+**File:** `core/src/utcp/data/auth.py`
+
+### class Auth {#auth}
+
+
+Documentation
+
+Authentication details for a provider.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier.
+
+
+#### Fields:
+
+- auth_type: str
+
+---
+
+### class AuthSerializer ([Serializer](./../interfaces/serializer.md#serializer)[Auth]) {#authserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for authentication details.
+
+Defines the contract for serializers that convert authentication details to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting authentication details to dictionaries for storage or transmission
+- Converting dictionaries back to authentication details
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- auth_serializers: dict[str, [Serializer](./../interfaces/serializer.md#serializer)[Auth]]
+
+#### Methods:
+
+
+to_dict(self, obj: Auth) -> dict
+
+Convert an Auth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The Auth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the Auth object.
+
+
+
+validate_dict(self, obj: dict) -> Auth
+
+Validate a dictionary and convert it to an Auth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The Auth object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/auth_implementations/api_key_auth.md b/docs/api/core/utcp/data/auth_implementations/api_key_auth.md
new file mode 100644
index 0000000..dedb21e
--- /dev/null
+++ b/docs/api/core/utcp/data/auth_implementations/api_key_auth.md
@@ -0,0 +1,84 @@
+---
+title: api_key_auth
+sidebar_label: api_key_auth
+---
+
+# api_key_auth
+
+**File:** `core/src/utcp/data/auth_implementations/api_key_auth.py`
+
+### class ApiKeyAuth ([Auth](./../auth.md#auth)) {#apikeyauth}
+
+
+Documentation
+
+Authentication using an API key.
+
+The key can be provided directly or sourced from an environment variable.
+Supports placement in headers, query parameters, or cookies.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "api_key".
+- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '${}' are
+ treated as an injected variable from environment or configuration.
+- **`var_name`**: The name of the header, query parameter, or cookie that
+ contains the API key.
+- **`location`**: Where to include the API key (header, query parameter, or cookie).
+
+
+#### Fields:
+
+- auth_type: Literal['api_key']
+- api_key: str
+- var_name: str
+- location: Literal['header', 'query', 'cookie']
+
+---
+
+### class ApiKeyAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[ApiKeyAuth]) {#apikeyauthserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for ApiKeyAuth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: ApiKeyAuth) -> dict
+
+Convert an ApiKeyAuth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The ApiKeyAuth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the ApiKeyAuth object.
+
+
+
+validate_dict(self, obj: dict) -> ApiKeyAuth
+
+Validate a dictionary and convert it to an ApiKeyAuth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The ApiKeyAuth object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/auth_implementations/basic_auth.md b/docs/api/core/utcp/data/auth_implementations/basic_auth.md
new file mode 100644
index 0000000..87f89ea
--- /dev/null
+++ b/docs/api/core/utcp/data/auth_implementations/basic_auth.md
@@ -0,0 +1,80 @@
+---
+title: basic_auth
+sidebar_label: basic_auth
+---
+
+# basic_auth
+
+**File:** `core/src/utcp/data/auth_implementations/basic_auth.py`
+
+### class BasicAuth ([Auth](./../auth.md#auth)) {#basicauth}
+
+
+Documentation
+
+Authentication using HTTP Basic Authentication.
+
+Uses the standard HTTP Basic Authentication scheme with username and password
+encoded in the Authorization header.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "basic".
+- **`username`**: The username for basic authentication. Recommended to use injected variables.
+- **`password`**: The password for basic authentication. Recommended to use injected variables.
+
+
+#### Fields:
+
+- auth_type: Literal['basic']
+- username: str
+- password: str
+
+---
+
+### class BasicAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[BasicAuth]) {#basicauthserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for BasicAuth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: BasicAuth) -> dict
+
+Convert a BasicAuth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The BasicAuth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the BasicAuth object.
+
+
+
+validate_dict(self, obj: dict) -> BasicAuth
+
+Validate a dictionary and convert it to a BasicAuth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The BasicAuth object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md b/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
new file mode 100644
index 0000000..9fe3024
--- /dev/null
+++ b/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
@@ -0,0 +1,84 @@
+---
+title: oauth2_auth
+sidebar_label: oauth2_auth
+---
+
+# oauth2_auth
+
+**File:** `core/src/utcp/data/auth_implementations/oauth2_auth.py`
+
+### class OAuth2Auth ([Auth](./../auth.md#auth)) {#oauth2auth}
+
+
+Documentation
+
+Authentication using OAuth2 client credentials flow.
+
+Implements the OAuth2 client credentials grant type for machine-to-machine
+authentication. The client automatically handles token acquisition and refresh.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "oauth2".
+- **`token_url`**: The URL endpoint to fetch the OAuth2 access token from. Recommended to use injected variables.
+- **`client_id`**: The OAuth2 client identifier. Recommended to use injected variables.
+- **`client_secret`**: The OAuth2 client secret. Recommended to use injected variables.
+- **`scope`**: Optional scope parameter to limit the access token's permissions.
+
+
+#### Fields:
+
+- auth_type: Literal['oauth2']
+- token_url: str
+- client_id: str
+- client_secret: str
+- scope: Optional[str]
+
+---
+
+### class OAuth2AuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[OAuth2Auth]) {#oauth2authserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for OAuth2Auth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: OAuth2Auth) -> dict
+
+Convert an OAuth2Auth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The OAuth2Auth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the OAuth2Auth object.
+
+
+
+validate_dict(self, obj: dict) -> OAuth2Auth
+
+Validate a dictionary and convert it to an OAuth2Auth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The OAuth2Auth object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/call_template.md b/docs/api/core/utcp/data/call_template.md
new file mode 100644
index 0000000..37af01a
--- /dev/null
+++ b/docs/api/core/utcp/data/call_template.md
@@ -0,0 +1,93 @@
+---
+title: call_template
+sidebar_label: call_template
+---
+
+# call_template
+
+**File:** `core/src/utcp/data/call_template.py`
+
+### class CallTemplate {#calltemplate}
+
+
+Documentation
+
+Base class for all UTCP tool providers.
+
+This is the abstract base class that all specific call template implementations
+inherit from. It provides the common fields that every provider must have.
+
+
+**Attributes**
+
+- **`name`**: Unique identifier for the provider. Defaults to a random UUID hex string.
+ Should be unique across all providers and recommended to be set to a human-readable name.
+ Can only contain letters, numbers and underscores. All special characters must be replaced with underscores.
+- **`call_template_type`**: The transport protocol type used by this provider.
+
+
+#### Fields:
+
+- name: str
+- call_template_type: str
+- auth: Optional[[Auth](./auth.md#auth)]
+
+---
+
+### class CallTemplateSerializer ([Serializer](./../interfaces/serializer.md#serializer)[CallTemplate]) {#calltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for call templates.
+
+Defines the contract for serializers that convert call templates to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting call templates to dictionaries for storage or transmission
+- Converting dictionaries back to call templates
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- call_template_serializers: dict[str, [Serializer](./../interfaces/serializer.md#serializer)[CallTemplate]]
+
+#### Methods:
+
+
+to_dict(self, obj: CallTemplate) -> dict
+
+Convert a CallTemplate object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The CallTemplate object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the CallTemplate object.
+
+
+
+validate_dict(self, obj: dict) -> CallTemplate
+
+Validate a dictionary and convert it to a CallTemplate object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The CallTemplate object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/register_manual_response.md b/docs/api/core/utcp/data/register_manual_response.md
new file mode 100644
index 0000000..86102db
--- /dev/null
+++ b/docs/api/core/utcp/data/register_manual_response.md
@@ -0,0 +1,33 @@
+---
+title: register_manual_response
+sidebar_label: register_manual_response
+---
+
+# register_manual_response
+
+**File:** `core/src/utcp/data/register_manual_response.py`
+
+### class RegisterManualResult {#registermanualresult}
+
+
+Documentation
+
+Result of a manual registration.
+
+
+**Attributes**
+
+- **`manual_call_template`**: The call template of the registered manual.
+- **`manual`**: The registered manual.
+- **`success`**: Whether the registration was successful.
+- **`errors`**: List of error messages if registration failed.
+
+
+#### Fields:
+
+- manual_call_template: [CallTemplate](./call_template.md#calltemplate)
+- manual: [UtcpManual](./utcp_manual.md#utcpmanual)
+- success: bool
+- errors: List[str]
+
+---
diff --git a/docs/api/core/utcp/data/tool.md b/docs/api/core/utcp/data/tool.md
new file mode 100644
index 0000000..549fc37
--- /dev/null
+++ b/docs/api/core/utcp/data/tool.md
@@ -0,0 +1,200 @@
+---
+title: tool
+sidebar_label: tool
+---
+
+# tool
+
+**File:** `core/src/utcp/data/tool.py`
+
+### class JsonSchema {#jsonschema}
+
+
+Documentation
+
+JSON Schema for tool inputs and outputs.
+
+
+**Attributes**
+
+- **`schema_`**: Optional schema identifier.
+- **`id_`**: Optional schema identifier.
+- **`title`**: Optional schema title.
+- **`description`**: Optional schema description.
+- **`type`**: Optional schema type.
+- **`properties`**: Optional schema properties.
+- **`items`**: Optional schema items.
+- **`required`**: Optional schema required fields.
+- **`enum`**: Optional schema enum values.
+- **`const`**: Optional schema constant value.
+- **`default`**: Optional schema default value.
+- **`format`**: Optional schema format.
+- **`additionalProperties`**: Optional schema additional properties.
+
+
+#### Fields:
+
+- schema_: Optional[str]
+- id_: Optional[str]
+- title: Optional[str]
+- description: Optional[str]
+- type: Optional[Union[str, List[str]]]
+- properties: Optional[Dict[str, 'JsonSchema']]
+- items: Optional[Union['JsonSchema', List['JsonSchema']]]
+- required: Optional[List[str]]
+- enum: Optional[List[JsonType]]
+- const: Optional[JsonType]
+- default: Optional[JsonType]
+- format: Optional[str]
+- additionalProperties: Optional[Union[bool, 'JsonSchema']]
+- pattern: Optional[str]
+- minimum: Optional[float]
+- maximum: Optional[float]
+- minLength: Optional[int]
+- maxLength: Optional[int]
+- `model_config`
+
+---
+
+### class JsonSchemaSerializer ([Serializer](./../interfaces/serializer.md#serializer)[JsonSchema]) {#jsonschemaserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for JSON Schema.
+
+Defines the contract for serializers that convert JSON Schema to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting JSON Schema to dictionaries for storage or transmission
+- Converting dictionaries back to JSON Schema
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: JsonSchema) -> dict
+
+Convert a JsonSchema object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The JsonSchema object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the JsonSchema object.
+
+
+
+validate_dict(self, obj: dict) -> JsonSchema
+
+Validate a dictionary and convert it to a JsonSchema object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The JsonSchema object converted from the dictionary.
+
+
+---
+
+### class Tool {#tool}
+
+
+Documentation
+
+Definition of a UTCP tool.
+
+Represents a callable tool with its metadata, input/output schemas,
+and provider configuration. Tools are the fundamental units of
+functionality in the UTCP ecosystem.
+
+
+**Attributes**
+
+- **`name`**: Unique identifier for the tool, typically in format "provider.tool_name".
+- **`description`**: Human-readable description of what the tool does.
+- **`inputs`**: JSON Schema defining the tool's input parameters.
+- **`outputs`**: JSON Schema defining the tool's return value structure.
+- **`tags`**: List of tags for categorization and search.
+- **`average_response_size`**: Optional hint about typical response size in bytes.
+- **`tool_call_template`**: [CallTemplate](./call_template.md#calltemplate) configuration for accessing this tool.
+
+
+#### Fields:
+
+- name: str
+- description: str
+- inputs: JsonSchema
+- outputs: JsonSchema
+- tags: List[str]
+- average_response_size: Optional[int]
+- tool_call_template: [CallTemplate](./call_template.md#calltemplate)
+
+---
+
+### class ToolSerializer ([Serializer](./../interfaces/serializer.md#serializer)[Tool]) {#toolserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for tools.
+
+Defines the contract for serializers that convert tools to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tools to dictionaries for storage or transmission
+- Converting dictionaries back to tools
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: Tool) -> dict
+
+Convert a Tool object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The Tool object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the Tool object.
+
+
+
+validate_dict(self, obj: dict) -> Tool
+
+Validate a dictionary and convert it to a Tool object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The Tool object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/utcp_client_config.md b/docs/api/core/utcp/data/utcp_client_config.md
new file mode 100644
index 0000000..5f0a6c7
--- /dev/null
+++ b/docs/api/core/utcp/data/utcp_client_config.md
@@ -0,0 +1,128 @@
+---
+title: utcp_client_config
+sidebar_label: utcp_client_config
+---
+
+# utcp_client_config
+
+**File:** `core/src/utcp/data/utcp_client_config.py`
+
+### class UtcpClientConfig {#utcpclientconfig}
+
+
+Documentation
+
+Configuration model for UTCP client setup.
+
+Provides comprehensive configuration options for UTCP clients including
+variable definitions, provider file locations, and variable loading
+mechanisms. Supports hierarchical variable resolution with multiple
+sources.
+
+
+**Variable Resolution Order**
+
+1. Direct variables dictionary
+2. Custom variable loaders (in order)
+3. Environment variables
+
+
+
+**Attributes**
+
+variables for substitution.
+variable loader configurations for loading variables from external
+sources like .env files or remote services.
+repository, which manages the storage and retrieval of tools.
+Defaults to an in-memory repository.
+search strategy, defining how tools are looked up. Defaults to a
+tag and description-based search.
+configurations to be applied after a tool call.
+call templates for registering tools that don't have a provider.
+
+
+
+**Example**
+
+```python
+ config = UtcpClientConfig(
+ variables={"MANUAL__NAME_API_KEY_NAME": "$REMAPPED_API_KEY"},
+ load_variables_from=[
+ VariableLoaderSerializer().validate_dict({"variable_loader_type": "dotenv", "env_file_path": ".env"})
+ ],
+ tool_repository={
+ "tool_repository_type": "in_memory"
+ },
+ tool_search_strategy={
+ "tool_search_strategy_type": "tag_and_description_word_match"
+ },
+ post_processing=[],
+ manual_call_templates=[]
+ )
+```
+
+
+#### Fields:
+
+- variables: Optional[Dict[str, str]]
+- load_variables_from: Optional[List[[VariableLoader](./variable_loader.md#variableloader)]]
+- tool_repository: [ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)
+- tool_search_strategy: [ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)
+- post_processing: List[[ToolPostProcessor](./../interfaces/tool_post_processor.md#toolpostprocessor)]
+- manual_call_templates: List[[CallTemplate](./call_template.md#calltemplate)]
+
+---
+
+### class UtcpClientConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpClientConfig]) {#utcpclientconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for UTCP client configurations.
+
+Defines the contract for serializers that convert UTCP client configurations to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting UTCP client configurations to dictionaries for storage or transmission
+- Converting dictionaries back to UTCP client configurations
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: UtcpClientConfig) -> dict
+
+Convert a UtcpClientConfig object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The UtcpClientConfig object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the UtcpClientConfig object.
+
+
+
+validate_dict(self, data: dict) -> UtcpClientConfig
+
+Validate a dictionary and convert it to a UtcpClientConfig object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The UtcpClientConfig object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/utcp_manual.md b/docs/api/core/utcp/data/utcp_manual.md
new file mode 100644
index 0000000..10633e2
--- /dev/null
+++ b/docs/api/core/utcp/data/utcp_manual.md
@@ -0,0 +1,115 @@
+---
+title: utcp_manual
+sidebar_label: utcp_manual
+---
+
+# utcp_manual
+
+**File:** `core/src/utcp/data/utcp_manual.py`
+
+### class UtcpManual {#utcpmanual}
+
+
+Documentation
+
+Standard format for tool provider responses during discovery.
+
+Represents the complete set of tools available from a provider, along
+with version information for compatibility checking. This format is
+returned by tool providers when clients query for available tools
+(e.g., through the `/utcp` endpoint or similar discovery mechanisms).
+
+The manual serves as the authoritative source of truth for what tools
+a provider offers and how they should be invoked.
+
+
+**Attributes**
+
+- **`version`**: UTCP protocol version supported by the provider.
+ Defaults to the current library version.
+- **`tools`**: List of available tools with their complete configurations
+ including input/output schemas, descriptions, and metadata.
+
+
+
+**Example**
+
+```python
+ @utcp_tool
+
+
+**Def Tool1()**
+
+pass
+
+@utcp_tool
+
+
+**Def Tool2()**
+
+pass
+
+# Create a manual from registered tools
+manual = UtcpManual.create_from_decorators()
+
+# Manual with specific tools
+manual = UtcpManual.create_from_decorators(
+manual_version="1.0.0",
+exclude=["tool1"]
+)
+```
+
+
+#### Fields:
+
+- utcp_version: str
+- manual_version: str
+- tools: List[[Tool](./tool.md#tool)]
+
+---
+
+### class UtcpManualSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpManual]) {#utcpmanualserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for UtcpManual model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: UtcpManual) -> dict
+
+Convert a UtcpManual object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The UtcpManual object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the UtcpManual object.
+
+
+
+validate_dict(self, data: dict) -> UtcpManual
+
+Validate a dictionary and convert it to a UtcpManual object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The UtcpManual object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/variable_loader.md b/docs/api/core/utcp/data/variable_loader.md
new file mode 100644
index 0000000..397eb6b
--- /dev/null
+++ b/docs/api/core/utcp/data/variable_loader.md
@@ -0,0 +1,101 @@
+---
+title: variable_loader
+sidebar_label: variable_loader
+---
+
+# variable_loader
+
+**File:** `core/src/utcp/data/variable_loader.py`
+
+### class VariableLoader {#variableloader}
+
+
+Documentation
+
+Abstract base class for variable loading configurations.
+
+Defines the interface for variable loaders that can retrieve variable
+values from different sources such as files, databases, or external
+services. Implementations provide specific loading mechanisms while
+maintaining a consistent interface.
+
+
+**Attributes**
+
+- **`variable_loader_type`**: Type identifier for the variable loader.
+
+
+#### Fields:
+
+- variable_loader_type: str
+
+#### Methods:
+
+
+get(self, key: str) -> Optional[str]
+
+Retrieve a variable value by key.
+
+
+**Args**
+
+- **`key`**: Variable name to retrieve.
+
+
+
+**Returns**
+
+Variable value if found, None otherwise.
+
+
+---
+
+### class VariableLoaderSerializer ([Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]) {#variableloaderserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for VariableLoader model.
+
+
+#### Fields:
+
+- loader_serializers: Dict[str, Type[[Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]]]
+
+#### Methods:
+
+
+to_dict(self, obj: VariableLoader) -> dict
+
+Convert a VariableLoader object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The VariableLoader object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the VariableLoader object.
+
+
+
+validate_dict(self, data: dict) -> VariableLoader
+
+Validate a dictionary and convert it to a VariableLoader object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The VariableLoader object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md b/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
new file mode 100644
index 0000000..7006cd1
--- /dev/null
+++ b/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
@@ -0,0 +1,106 @@
+---
+title: dot_env_variable_loader
+sidebar_label: dot_env_variable_loader
+---
+
+# dot_env_variable_loader
+
+**File:** `core/src/utcp/data/variable_loader_implementations/dot_env_variable_loader.py`
+
+### class DotEnvVariableLoader ([VariableLoader](./../variable_loader.md#variableloader)) {#dotenvvariableloader}
+
+
+Documentation
+
+Environment file variable loader implementation.
+
+Loads variables from .env files using the dotenv format. This loader
+supports the standard key=value format with optional quoting and
+comment support provided by the python-dotenv library.
+
+
+**Attributes**
+
+- **`env_file_path`**: Path to the .env file to load variables from.
+
+
+
+**Example**
+
+```python
+ loader = DotEnvVariableLoader(env_file_path=".env")
+ api_key = loader.get("API_KEY")
+```
+
+
+#### Fields:
+
+- variable_loader_type: Literal['dotenv']
+- env_file_path: str
+
+#### Methods:
+
+
+get(self, key: str) -> Optional[str]
+
+Load a variable from the configured .env file.
+
+
+**Args**
+
+- **`key`**: Variable name to retrieve from the environment file.
+
+
+
+**Returns**
+
+Variable value if found in the file, None otherwise.
+
+
+---
+
+### class DotEnvVariableLoaderSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[DotEnvVariableLoader]) {#dotenvvariableloaderserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for DotEnvVariableLoader model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: DotEnvVariableLoader) -> dict
+
+Convert a DotEnvVariableLoader object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The DotEnvVariableLoader object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the DotEnvVariableLoader object.
+
+
+
+validate_dict(self, data: dict) -> DotEnvVariableLoader
+
+Validate a dictionary and convert it to a DotEnvVariableLoader object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The DotEnvVariableLoader object converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md b/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
new file mode 100644
index 0000000..dd4e59e
--- /dev/null
+++ b/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
@@ -0,0 +1,18 @@
+---
+title: utcp_serializer_validation_error
+sidebar_label: utcp_serializer_validation_error
+---
+
+# utcp_serializer_validation_error
+
+**File:** `core/src/utcp/exceptions/utcp_serializer_validation_error.py`
+
+### class UtcpSerializerValidationError {#utcpserializervalidationerror}
+
+
+Documentation
+
+Exception raised when a serializer validation fails.
+
+
+---
diff --git a/docs/api/core/utcp/exceptions/utcp_variable_not_found_exception.md b/docs/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
new file mode 100644
index 0000000..ee5ec1f
--- /dev/null
+++ b/docs/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
@@ -0,0 +1,45 @@
+---
+title: utcp_variable_not_found_exception
+sidebar_label: utcp_variable_not_found_exception
+---
+
+# utcp_variable_not_found_exception
+
+**File:** `core/src/utcp/exceptions/utcp_variable_not_found_exception.py`
+
+### class UtcpVariableNotFound {#utcpvariablenotfound}
+
+
+Documentation
+
+Exception raised when a required variable cannot be found.
+
+This exception is thrown during variable substitution when a referenced
+variable cannot be resolved through any of the configured variable sources.
+It provides information about which variable was missing to help with
+debugging configuration issues.
+
+
+**Attributes**
+
+- **`variable_name`**: The name of the variable that could not be found.
+
+
+#### Fields:
+
+- variable_name: str
+
+#### Methods:
+
+
+__init__(self, variable_name: str)
+
+Initialize the exception with the missing variable name.
+
+
+**Args**
+
+- **`variable_name`**: Name of the variable that could not be found.
+
+
+---
diff --git a/docs/api/core/utcp/implementations/default_variable_substitutor.md b/docs/api/core/utcp/implementations/default_variable_substitutor.md
new file mode 100644
index 0000000..1300ef6
--- /dev/null
+++ b/docs/api/core/utcp/implementations/default_variable_substitutor.md
@@ -0,0 +1,132 @@
+---
+title: default_variable_substitutor
+sidebar_label: default_variable_substitutor
+---
+
+# default_variable_substitutor
+
+**File:** `core/src/utcp/implementations/default_variable_substitutor.py`
+
+### class DefaultVariableSubstitutor ([VariableSubstitutor](./../interfaces/variable_substitutor.md#variablesubstitutor)) {#defaultvariablesubstitutor}
+
+
+Documentation
+
+Default implementation of variable substitution.
+
+Provides a hierarchical variable resolution system that searches for
+
+**Variables In The Following Order**
+
+1. Configuration variables (exact match)
+2. Custom variable loaders (in order)
+3. Environment variables
+
+
+
+**Features**
+
+- Provider-specific variable namespacing
+- Hierarchical variable resolution
+- Recursive substitution in nested data structures
+- Variable discovery for validation
+
+
+
+**Variable Namespacing**
+
+Provider-specific variables are prefixed with the provider name
+to avoid conflicts. For example, a variable 'api_key' for provider
+'web_scraper' becomes 'web__scraper_api_key' internally.
+
+
+#### Methods:
+
+
+substitute(self, obj: dict | list | str, config: [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig), variable_namespace: Optional[str]) -> Any
+
+Recursively substitute variables in nested data structures.
+
+Performs deep substitution on dictionaries, lists, and strings.
+Non-string types are returned unchanged. String values are scanned
+for variable references using ${VAR} and $VAR syntax.
+
+
+**Args**
+
+- **`obj`**: Object to perform substitution on. Can be any type.
+- **`config`**: UTCP client configuration containing variable sources.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+Object with all variable references replaced. Structure and
+non-string values are preserved.
+
+
+
+**Raises**
+
+- **`[UtcpVariableNotFound](./../exceptions/utcp_variable_not_found_exception.md#utcpvariablenotfound)`**: If any referenced variable cannot be resolved.
+- **`ValueError`**: If variable_namespace contains invalid characters.
+
+
+
+**Example**
+
+```python
+ substitutor = DefaultVariableSubstitutor()
+ result = substitutor.substitute(
+ {"url": "https://${HOST}/api", "port": 8080},
+ config,
+ "my_provider"
+ )
+ # Returns: {"url": "https://api.example.com/api", "port": 8080}
+```
+
+
+
+find_required_variables(self, obj: dict | list | str, variable_namespace: Optional[str]) -> List[str]
+
+Recursively discover all variable references in a data structure.
+
+Scans the object for variable references using ${VAR} and $VAR syntax,
+returning fully-qualified variable names with variable namespacing.
+Useful for validation and dependency analysis.
+
+
+**Args**
+
+- **`obj`**: Object to scan for variable references.
+- **`variable_namespace`**: Variable namespace used for variable namespacing.
+ Variable names are prefixed with this variable namespace.
+
+
+
+**Raises**
+
+- **`ValueError`**: If variable_namespace contains invalid characters.
+
+
+
+**Returns**
+
+List of fully-qualified variable names found in the object.
+
+
+
+**Example**
+
+```python
+ substitutor = DefaultVariableSubstitutor()
+ vars = substitutor.find_required_variables(
+ {"url": "https://${HOST}/api", "key": "$API_KEY"},
+ "web_api"
+ )
+ # Returns: ["web__api_HOST", "web__api_API_KEY"]
+```
+
+
+---
diff --git a/docs/api/core/utcp/implementations/in_mem_tool_repository.md b/docs/api/core/utcp/implementations/in_mem_tool_repository.md
new file mode 100644
index 0000000..b8e39c6
--- /dev/null
+++ b/docs/api/core/utcp/implementations/in_mem_tool_repository.md
@@ -0,0 +1,219 @@
+---
+title: in_mem_tool_repository
+sidebar_label: in_mem_tool_repository
+---
+
+# in_mem_tool_repository
+
+**File:** `core/src/utcp/implementations/in_mem_tool_repository.py`
+
+### class InMemToolRepository ([ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)) {#inmemtoolrepository}
+
+
+Documentation
+
+Thread-safe in-memory implementation of `[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)`.
+
+Stores tools and their associated manual call templates in dictionaries and
+protects all operations with a read-write lock to ensure consistency under
+concurrency while allowing multiple concurrent readers.
+
+
+#### Methods:
+
+
+async save_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate), manual: [UtcpManual](./../data/utcp_manual.md#utcpmanual)) -> None
+
+Save a manual and its associated tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The manual call template to save.
+- **`manual`**: The manual to save.
+
+
+
+async remove_manual(self, manual_name: str) -> bool
+
+Remove a manual and its associated tools.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to remove.
+
+
+
+**Returns**
+
+True if the manual was removed, False otherwise.
+
+
+
+async remove_tool(self, tool_name: str) -> bool
+
+Remove a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to remove.
+
+
+
+**Returns**
+
+True if the tool was removed, False otherwise.
+
+
+
+async get_tool(self, tool_name: str) -> Optional[[Tool](./../data/tool.md#tool)]
+
+Get a tool by name.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to get.
+
+
+
+**Returns**
+
+The tool if it exists, None otherwise.
+
+
+
+async get_tools(self) -> List[[Tool](./../data/tool.md#tool)]
+
+Get all tools in the repository.
+
+
+**Returns**
+
+A list of all tools in the repository.
+
+
+
+async get_tools_by_manual(self, manual_name: str) -> Optional[List[[Tool](./../data/tool.md#tool)]]
+
+Get all tools associated with a manual.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to get tools for.
+
+
+
+**Returns**
+
+A list of tools associated with the manual, or None if the manual does not exist.
+
+
+
+async get_manual(self, manual_name: str) -> Optional[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get a manual by name.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to get.
+
+
+
+**Returns**
+
+The manual if it exists, None otherwise.
+
+
+
+async get_manuals(self) -> List[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get all manuals in the repository.
+
+
+**Returns**
+
+A list of all manuals in the repository.
+
+
+
+async get_manual_call_template(self, manual_call_template_name: str) -> Optional[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get a manual call template by name.
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the manual call template to get.
+
+
+
+**Returns**
+
+The manual call template if it exists, None otherwise.
+
+
+
+async get_manual_call_templates(self) -> List[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get all manual call templates in the repository.
+
+
+**Returns**
+
+A list of all manual call templates in the repository.
+
+
+---
+
+### class InMemToolRepositoryConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[InMemToolRepository]) {#inmemtoolrepositoryconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for `InMemToolRepository`.
+
+Converts an `InMemToolRepository` instance to a dictionary and vice versa.
+
+
+#### Methods:
+
+
+to_dict(self, obj: InMemToolRepository) -> dict
+
+Convert an `InMemToolRepository` instance to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The `InMemToolRepository` instance to convert.
+
+
+
+**Returns**
+
+A dictionary representing the `InMemToolRepository` instance.
+
+
+
+validate_dict(self, data: dict) -> InMemToolRepository
+
+Convert a dictionary to an `InMemToolRepository` instance.
+
+
+**Args**
+
+- **`data`**: The dictionary to convert.
+
+
+
+**Returns**
+
+An `InMemToolRepository` instance representing the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/implementations/tag_search.md b/docs/api/core/utcp/implementations/tag_search.md
new file mode 100644
index 0000000..63dcc22
--- /dev/null
+++ b/docs/api/core/utcp/implementations/tag_search.md
@@ -0,0 +1,96 @@
+---
+title: tag_search
+sidebar_label: tag_search
+---
+
+# tag_search
+
+**File:** `core/src/utcp/implementations/tag_search.py`
+
+### class TagAndDescriptionWordMatchStrategy ([ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)) {#taganddescriptionwordmatchstrategy}
+
+
+Documentation
+
+Tag and description word match strategy.
+
+This strategy matches tools based on the presence of tags and words in the description.
+
+
+#### Fields:
+
+- tool_search_strategy_type: Literal['tag_and_description_word_match']
+- description_weight: float
+- tag_weight: float
+
+#### Methods:
+
+
+async search_tools(self, tool_repository: [ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository), query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools based on the given query.
+
+
+**Args**
+
+- **`tool_repository`**: The tool repository to search in.
+- **`query`**: The query to search for.
+- **`limit`**: The maximum number of results to return.
+- **`any_of_tags_required`**: A list of tags that must be present in the tool.
+
+
+
+**Returns**
+
+A list of tools that match the query.
+
+
+---
+
+### class TagAndDescriptionWordMatchStrategyConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[TagAndDescriptionWordMatchStrategy]) {#taganddescriptionwordmatchstrategyconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for `TagAndDescriptionWordMatchStrategy`.
+
+Converts a `TagAndDescriptionWordMatchStrategy` instance to a dictionary and vice versa.
+
+
+#### Methods:
+
+
+to_dict(self, obj: TagAndDescriptionWordMatchStrategy) -> dict
+
+Convert a `TagAndDescriptionWordMatchStrategy` instance to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The `TagAndDescriptionWordMatchStrategy` instance to convert.
+
+
+
+**Returns**
+
+A dictionary representing the `TagAndDescriptionWordMatchStrategy` instance.
+
+
+
+validate_dict(self, data: dict) -> TagAndDescriptionWordMatchStrategy
+
+Convert a dictionary to a `TagAndDescriptionWordMatchStrategy` instance.
+
+
+**Args**
+
+- **`data`**: The dictionary to convert.
+
+
+
+**Returns**
+
+A `TagAndDescriptionWordMatchStrategy` instance representing the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/implementations/utcp_client_implementation.md b/docs/api/core/utcp/implementations/utcp_client_implementation.md
new file mode 100644
index 0000000..b969a77
--- /dev/null
+++ b/docs/api/core/utcp/implementations/utcp_client_implementation.md
@@ -0,0 +1,180 @@
+---
+title: utcp_client_implementation
+sidebar_label: utcp_client_implementation
+---
+
+# utcp_client_implementation
+
+**File:** `core/src/utcp/implementations/utcp_client_implementation.py`
+
+### class UtcpClientImplementation ([UtcpClient](./../utcp_client.md#utcpclient)) {#utcpclientimplementation}
+
+
+Documentation
+
+Implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
+
+This class provides a concrete implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
+
+
+#### Methods:
+
+
+async create(cls, root_dir: Optional[str], config: Optional[Union[str, Dict[str, Any], [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig)]]) -> '[UtcpClient](./../utcp_client.md#utcpclient)'
+
+Create a new `[UtcpClient](./../utcp_client.md#utcpclient)` instance.
+
+
+**Args**
+
+- **`root_dir`**: The root directory for the client.
+- **`config`**: The configuration for the client.
+
+
+
+**Returns**
+
+A new `[UtcpClient](./../utcp_client.md#utcpclient)` instance.
+
+
+
+async register_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> [RegisterManualResult](./../data/register_manual_response.md#registermanualresult)
+
+Register a manual in the client.
+
+
+**Args**
+
+- **`manual_call_template`**: The `[CallTemplate](./../data/call_template.md#calltemplate)` instance representing the manual to register.
+
+
+
+**Returns**
+
+A `[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)` instance representing the result of the registration.
+
+
+
+async register_manuals(self, manual_call_templates: List[[CallTemplate](./../data/call_template.md#calltemplate)]) -> List[[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)]
+
+Register multiple manuals in the client.
+
+
+**Args**
+
+- **`manual_call_templates`**: A list of `[CallTemplate](./../data/call_template.md#calltemplate)` instances representing the manuals to register.
+
+
+
+**Returns**
+
+A list of `[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)` instances representing the results of the registration.
+
+
+
+async deregister_manual(self, manual_name: str) -> bool
+
+Deregister a manual from the client.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to deregister.
+
+
+
+**Returns**
+
+A boolean indicating whether the manual was successfully deregistered.
+
+
+
+async call_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> Any
+
+Call a tool in the client.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: A dictionary of arguments to pass to the tool.
+
+
+
+**Returns**
+
+The result of the tool call.
+
+
+
+async call_tool_streaming(self, tool_name: str, tool_args: Dict[str, Any]) -> AsyncGenerator[Any, None]
+
+Call a tool in the client streamingly.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: A dictionary of arguments to pass to the tool.
+
+
+
+**Returns**
+
+An async generator yielding the result of the tool call.
+
+
+
+async search_tools(self, query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools based on the given query.
+
+
+**Args**
+
+- **`query`**: The query to search for.
+- **`limit`**: The maximum number of results to return.
+- **`any_of_tags_required`**: A list of tags that must be present in the tool.
+
+
+
+**Returns**
+
+A list of tools that match the query.
+
+
+
+async get_required_variables_for_manual_and_tools(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> List[str]
+
+Get the required variables for a manual and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The `[CallTemplate](./../data/call_template.md#calltemplate)` instance representing the manual.
+
+
+
+**Returns**
+
+A list of required variables for the manual and its tools.
+
+
+
+async get_required_variables_for_registered_tool(self, tool_name: str) -> List[str]
+
+Get the required variables for a registered tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool.
+
+
+
+**Returns**
+
+A list of required variables for the tool.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/communication_protocol.md b/docs/api/core/utcp/interfaces/communication_protocol.md
new file mode 100644
index 0000000..9ec814e
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/communication_protocol.md
@@ -0,0 +1,152 @@
+---
+title: communication_protocol
+sidebar_label: communication_protocol
+---
+
+# communication_protocol
+
+**File:** `core/src/utcp/interfaces/communication_protocol.py`
+
+### class CommunicationProtocol {#communicationprotocol}
+
+
+Documentation
+
+Abstract interface for UTCP client transport implementations.
+
+Defines the contract that all transport implementations must follow to
+integrate with the UTCP client. Each transport handles communication
+with a specific type of provider (HTTP, CLI, WebSocket, etc.).
+
+
+**Transport Implementations Are Responsible For**
+
+- Discovering available tools from providers
+- Managing provider lifecycle (registration/deregistration)
+- Executing tool calls through the appropriate protocol
+
+
+#### Fields:
+
+- communication_protocols: dict[str, 'CommunicationProtocol']
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> [RegisterManualResult](./../data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools.
+
+Connects to the provider and retrieves the list of tools it offers.
+This may involve making discovery requests, parsing configuration files,
+or initializing connections depending on the provider type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to register.
+
+
+
+**Returns**
+
+[RegisterManualResult](./../data/register_manual_response.md#registermanualresult) object containing the call template and manual.
+
+
+
+**Raises**
+
+- **`ConnectionError`**: If unable to connect to the provider.
+- **`ValueError`**: If the provider configuration is invalid.
+
+
+
+async deregister_manual(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> None
+
+Deregister a manual and its tools.
+
+Cleanly disconnects from the provider and releases any associated
+resources such as connections, processes, or file handles.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to deregister.
+
+
+
+**Note**
+
+Should handle cases where the provider is already disconnected
+or was never properly registered.
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through this transport.
+
+Sends a tool invocation request to the provider using the appropriate
+protocol and returns the result. Handles serialization of arguments
+and deserialization of responses according to the transport type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+The tool's response, with type depending on the tool's output schema.
+
+
+
+**Raises**
+
+- **`ToolNotFoundError`**: If the specified tool doesn't exist.
+- **`ValidationError`**: If the arguments don't match the tool's input schema.
+- **`ConnectionError`**: If unable to communicate with the provider.
+- **`TimeoutError`**: If the tool call exceeds the configured timeout.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through this transport streamingly.
+
+Sends a tool invocation request to the provider using the appropriate
+protocol and returns the result. Handles serialization of arguments
+and deserialization of responses according to the transport type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+An async generator that yields the tool's response, with type depending on the tool's output schema.
+
+
+
+**Raises**
+
+- **`ToolNotFoundError`**: If the specified tool doesn't exist.
+- **`ValidationError`**: If the arguments don't match the tool's input schema.
+- **`ConnectionError`**: If unable to communicate with the provider.
+- **`TimeoutError`**: If the tool call exceeds the configured timeout.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/concurrent_tool_repository.md b/docs/api/core/utcp/interfaces/concurrent_tool_repository.md
new file mode 100644
index 0000000..e58b5da
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/concurrent_tool_repository.md
@@ -0,0 +1,192 @@
+---
+title: concurrent_tool_repository
+sidebar_label: concurrent_tool_repository
+---
+
+# concurrent_tool_repository
+
+**File:** `core/src/utcp/interfaces/concurrent_tool_repository.py`
+
+### class ConcurrentToolRepository {#concurrenttoolrepository}
+
+
+Documentation
+
+Abstract interface for tool and provider storage implementations.
+
+Defines the contract for repositories that manage the lifecycle and storage
+
+**Of Utcp Tools And Call Templates. Repositories Are Responsible For**
+
+- Persisting provider configurations and their associated tools
+- Providing efficient lookup and retrieval operations
+- Managing relationships between call templates and tools
+- Ensuring data consistency during operations
+- Thread safety
+
+The repository interface supports both individual and bulk operations,
+allowing for flexible implementation strategies ranging from simple
+in-memory storage to sophisticated database backends.
+
+
+
+**Note**
+
+All methods are async to support both synchronous and asynchronous
+storage implementations.
+
+
+#### Fields:
+
+- tool_repository_type: str
+
+#### Methods:
+
+
+async save_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate), manual: [UtcpManual](./../data/utcp_manual.md#utcpmanual)) -> None
+
+Save a manual and its tools in the repository.
+
+
+**Args**
+
+- **`manual_call_template`**: The call template associated with the manual to save.
+- **`manual`**: The manual to save.
+
+
+
+async remove_manual(self, manual_name: str) -> bool
+
+Remove a manual and its tools from the repository.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to remove.
+
+
+
+**Returns**
+
+True if the manual was removed, False otherwise.
+
+
+
+async remove_tool(self, tool_name: str) -> bool
+
+Remove a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to remove.
+
+
+
+**Returns**
+
+True if the tool was removed, False otherwise.
+
+
+
+async get_tool(self, tool_name: str) -> Optional[[Tool](./../data/tool.md#tool)]
+
+Get a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to retrieve.
+
+
+
+**Returns**
+
+The tool if found, otherwise None.
+
+
+
+async get_tools(self) -> List[[Tool](./../data/tool.md#tool)]
+
+Get all tools from the repository.
+
+
+**Returns**
+
+A list of tools.
+
+
+
+async get_tools_by_manual(self, manual_name: str) -> Optional[List[[Tool](./../data/tool.md#tool)]]
+
+Get tools associated with a specific manual.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual.
+
+
+
+**Returns**
+
+A list of tools associated with the manual, or None if the manual is not found.
+
+
+
+async get_manual(self, manual_name: str) -> Optional[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get a manual from the repository.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to retrieve.
+
+
+
+**Returns**
+
+The manual if found, otherwise None.
+
+
+
+async get_manuals(self) -> List[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get all manuals from the repository.
+
+
+**Returns**
+
+A list of manuals.
+
+
+
+async get_manual_call_template(self, manual_call_template_name: str) -> Optional[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get a manual call template from the repository.
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the manual call template to retrieve.
+
+
+
+**Returns**
+
+The manual call template if found, otherwise None.
+
+
+
+async get_manual_call_templates(self) -> List[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get all manual call templates from the repository.
+
+
+**Returns**
+
+A list of manual call templates.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/serializer.md b/docs/api/core/utcp/interfaces/serializer.md
new file mode 100644
index 0000000..a7d284f
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/serializer.md
@@ -0,0 +1,79 @@
+---
+title: serializer
+sidebar_label: serializer
+---
+
+# serializer
+
+**File:** `core/src/utcp/interfaces/serializer.py`
+
+### class Serializer (Generic[T]) {#serializer}
+
+
+Documentation
+
+Abstract interface for serializers.
+
+Defines the contract for serializers that convert objects to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting objects to dictionaries for storage or transmission
+- Converting dictionaries back to objects
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+validate_dict(self, obj: dict) -> T
+
+Validate a dictionary and convert it to an object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The object converted from the dictionary.
+
+
+
+to_dict(self, obj: T) -> dict
+
+Convert an object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the object.
+
+
+
+copy(self, obj: T) -> T
+
+Create a copy of an object.
+
+
+**Args**
+
+- **`obj`**: The object to copy.
+
+
+
+**Returns**
+
+A copy of the object.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/tool_post_processor.md b/docs/api/core/utcp/interfaces/tool_post_processor.md
new file mode 100644
index 0000000..68eef6c
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/tool_post_processor.md
@@ -0,0 +1,109 @@
+---
+title: tool_post_processor
+sidebar_label: tool_post_processor
+---
+
+# tool_post_processor
+
+**File:** `core/src/utcp/interfaces/tool_post_processor.py`
+
+### class ToolPostProcessor {#toolpostprocessor}
+
+
+Documentation
+
+Abstract interface for tool post processors.
+
+Defines the contract for tool post processors that process the result of a tool call.
+
+**[Tool](./../data/tool.md#tool) Post Processors Are Responsible For**
+
+- Processing the result of a tool call
+- Returning the processed result
+
+
+#### Fields:
+
+- tool_post_processor_type: str
+
+#### Methods:
+
+
+post_process(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool: [Tool](./../data/tool.md#tool), manual_call_template: '[CallTemplate](./../data/call_template.md#calltemplate)', result: Any) -> Any
+
+Process the result of a tool call.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool`**: The tool that was called.
+- **`manual_call_template`**: The call template of the manual that was called.
+- **`result`**: The result of the tool call.
+
+
+
+**Returns**
+
+The processed result.
+
+
+---
+
+### class ToolPostProcessorConfigSerializer ([Serializer](./serializer.md#serializer)[ToolPostProcessor]) {#toolpostprocessorconfigserializer}
+
+
+Documentation
+
+[Serializer](./serializer.md#serializer) for tool post processors.
+
+Defines the contract for serializers that convert tool post processors to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tool post processors to dictionaries for storage or transmission
+- Converting dictionaries back to tool post processors
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- tool_post_processor_implementations: Dict[str, [Serializer](./serializer.md#serializer)[ToolPostProcessor]]
+
+#### Methods:
+
+
+to_dict(self, obj: ToolPostProcessor) -> dict
+
+Convert a tool post processor to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The tool post processor to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the tool post processor.
+
+
+
+validate_dict(self, data: dict) -> ToolPostProcessor
+
+Validate a dictionary and convert it to a tool post processor.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The tool post processor converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/tool_search_strategy.md b/docs/api/core/utcp/interfaces/tool_search_strategy.md
new file mode 100644
index 0000000..68dc8bc
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/tool_search_strategy.md
@@ -0,0 +1,130 @@
+---
+title: tool_search_strategy
+sidebar_label: tool_search_strategy
+---
+
+# tool_search_strategy
+
+**File:** `core/src/utcp/interfaces/tool_search_strategy.py`
+
+### class ToolSearchStrategy {#toolsearchstrategy}
+
+
+Documentation
+
+Abstract interface for tool search implementations.
+
+Defines the contract for tool search strategies that can be plugged into
+the UTCP client. Different implementations can provide various search
+algorithms such as tag-based matching, semantic similarity, or keyword
+search.
+
+
+**Search Strategies Are Responsible For**
+
+- Interpreting search queries
+- Ranking tools by relevance
+- Limiting results appropriately
+- Providing consistent search behavior
+
+
+#### Fields:
+
+- tool_search_strategy_type: str
+
+#### Methods:
+
+
+async search_tools(self, tool_repository: [ConcurrentToolRepository](./concurrent_tool_repository.md#concurrenttoolrepository), query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools relevant to the query.
+
+Executes a search against the available tools and returns the most
+relevant matches ranked by the strategy's scoring algorithm.
+
+
+**Args**
+
+- **`tool_repository`**: The tool repository to search within.
+- **`query`**: The search query string. Format depends on the strategy
+ (e.g., keywords, tags, natural language).
+- **`limit`**: Maximum number of tools to return. Use 0 for no limit.
+ Strategies should respect this limit for performance.
+- **`any_of_tags_required`**: Optional list of tags where one of them must be present in the tool's tags
+ for it to be considered a match.
+
+
+
+**Returns**
+
+List of [Tool](./../data/tool.md#tool) objects ranked by relevance, limited to the
+specified count. Empty list if no matches found.
+
+
+
+**Raises**
+
+- **`ValueError`**: If the query format is invalid for this strategy.
+- **`RuntimeError`**: If the search operation fails unexpectedly.
+
+
+---
+
+### class ToolSearchStrategyConfigSerializer ([Serializer](./serializer.md#serializer)[ToolSearchStrategy]) {#toolsearchstrategyconfigserializer}
+
+
+Documentation
+
+[Serializer](./serializer.md#serializer) for tool search strategies.
+
+Defines the contract for serializers that convert tool search strategies to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tool search strategies to dictionaries for storage or transmission
+- Converting dictionaries back to tool search strategies
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- tool_search_strategy_implementations: Dict[str, [Serializer](./serializer.md#serializer)['ToolSearchStrategy']]
+- `default_strategy`
+
+#### Methods:
+
+
+to_dict(self, obj: ToolSearchStrategy) -> dict
+
+Convert a tool search strategy to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The tool search strategy to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the tool search strategy.
+
+
+
+validate_dict(self, data: dict) -> ToolSearchStrategy
+
+Validate a dictionary and convert it to a tool search strategy.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The tool search strategy converted from the dictionary.
+
+
+---
diff --git a/docs/api/core/utcp/interfaces/variable_substitutor.md b/docs/api/core/utcp/interfaces/variable_substitutor.md
new file mode 100644
index 0000000..29568bc
--- /dev/null
+++ b/docs/api/core/utcp/interfaces/variable_substitutor.md
@@ -0,0 +1,69 @@
+---
+title: variable_substitutor
+sidebar_label: variable_substitutor
+---
+
+# variable_substitutor
+
+**File:** `core/src/utcp/interfaces/variable_substitutor.py`
+
+### class VariableSubstitutor {#variablesubstitutor}
+
+
+Documentation
+
+Abstract interface for variable substitution implementations.
+
+Defines the contract for variable substitution systems that can replace
+placeholders in configuration data with actual values from various sources.
+Implementations handle different variable resolution strategies and
+source hierarchies.
+
+
+#### Methods:
+
+
+substitute(self, obj: dict | list | str, config: [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig), variable_namespace: Optional[str]) -> Any
+
+Substitute variables in the given object.
+
+
+**Args**
+
+- **`obj`**: Object containing potential variable references to substitute.
+- **`config`**: UTCP client configuration containing variable definitions
+ and loaders.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+Object with all variable references replaced by their values.
+
+
+
+**Raises**
+
+- **`[UtcpVariableNotFound](./../exceptions/utcp_variable_not_found_exception.md#utcpvariablenotfound)`**: If a referenced variable cannot be resolved.
+
+
+
+find_required_variables(self, obj: dict | list | str, variable_namespace: Optional[str]) -> List[str]
+
+Find all variable references in the given object.
+
+
+**Args**
+
+- **`obj`**: Object to scan for variable references.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+List of fully-qualified variable names found in the object.
+
+
+---
diff --git a/docs/api/core/utcp/plugins/discovery.md b/docs/api/core/utcp/plugins/discovery.md
new file mode 100644
index 0000000..f26ffe2
--- /dev/null
+++ b/docs/api/core/utcp/plugins/discovery.md
@@ -0,0 +1,169 @@
+---
+title: discovery
+sidebar_label: discovery
+---
+
+# discovery
+
+**File:** `core/src/utcp/plugins/discovery.py`
+
+### Function register_auth(auth_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[Auth](./../data/auth.md#auth)], override: bool) -> bool {#register_auth}
+
+
+Documentation
+
+Register an authentication implementation.
+
+
+**Args**
+
+- **`auth_type`**: The authentication type identifier.
+- **`serializer`**: The serializer for the authentication implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_variable_loader(loader_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[VariableLoader](./../data/variable_loader.md#variableloader)], override: bool) -> bool {#register_variable_loader}
+
+
+Documentation
+
+Register a variable loader implementation.
+
+
+**Args**
+
+- **`loader_type`**: The variable loader type identifier.
+- **`serializer`**: The serializer for the variable loader implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_call_template(call_template_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[CallTemplate](./../data/call_template.md#calltemplate)], override: bool) -> bool {#register_call_template}
+
+
+Documentation
+
+Register a call template implementation.
+
+
+**Args**
+
+- **`call_template_type`**: The call template type identifier.
+- **`serializer`**: The serializer for the call template implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_communication_protocol(communication_protocol_type: str, communication_protocol: [CommunicationProtocol](./../interfaces/communication_protocol.md#communicationprotocol), override: bool) -> bool {#register_communication_protocol}
+
+
+Documentation
+
+Register a communication protocol implementation.
+
+
+**Args**
+
+- **`communication_protocol_type`**: The communication protocol type identifier.
+- **`communication_protocol`**: The communication protocol implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_repository(tool_repository_type: str, tool_repository: [Serializer](./../interfaces/serializer.md#serializer)[[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)], override: bool) -> bool {#register_tool_repository}
+
+
+Documentation
+
+Register a tool repository implementation.
+
+
+**Args**
+
+- **`tool_repository_type`**: The tool repository type identifier.
+- **`tool_repository`**: The tool repository implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_search_strategy(strategy_type: str, strategy: [Serializer](./../interfaces/serializer.md#serializer)[[ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)], override: bool) -> bool {#register_tool_search_strategy}
+
+
+Documentation
+
+Register a tool search strategy implementation.
+
+
+**Args**
+
+- **`strategy_type`**: The tool search strategy type identifier.
+- **`strategy`**: The tool search strategy implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_post_processor(tool_post_processor_type: str, tool_post_processor: [Serializer](./../interfaces/serializer.md#serializer)[[ToolPostProcessor](./../interfaces/tool_post_processor.md#toolpostprocessor)], override: bool) -> bool {#register_tool_post_processor}
+
+
+Documentation
+
+Register a tool post processor implementation.
+
+
+**Args**
+
+- **`tool_post_processor_type`**: The tool post processor type identifier.
+- **`tool_post_processor`**: The tool post processor implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
diff --git a/docs/api/core/utcp/plugins/plugin_loader.md b/docs/api/core/utcp/plugins/plugin_loader.md
new file mode 100644
index 0000000..17c25ef
--- /dev/null
+++ b/docs/api/core/utcp/plugins/plugin_loader.md
@@ -0,0 +1,20 @@
+---
+title: plugin_loader
+sidebar_label: plugin_loader
+---
+
+# plugin_loader
+
+**File:** `core/src/utcp/plugins/plugin_loader.py`
+
+### Function ensure_plugins_initialized() {#ensure_plugins_initialized}
+
+
+Documentation
+
+Ensure that plugins are initialized.
+
+This function should be called before using any plugin related functionality is used.
+
+
+---
diff --git a/docs/api/core/utcp/utcp_client.md b/docs/api/core/utcp/utcp_client.md
new file mode 100644
index 0000000..63428d9
--- /dev/null
+++ b/docs/api/core/utcp/utcp_client.md
@@ -0,0 +1,184 @@
+---
+title: utcp_client
+sidebar_label: utcp_client
+---
+
+# utcp_client
+
+**File:** `core/src/utcp/utcp_client.py`
+
+### class UtcpClient {#utcpclient}
+
+
+Documentation
+
+Abstract interface for UTCP client implementations.
+
+Defines the core contract for UTCP clients, including [CallTemplate](./data/call_template.md#calltemplate) management,
+tool execution, search capabilities, and variable handling. This interface
+allows for different client implementations while maintaining consistency.
+
+
+#### Methods:
+
+
+async create(cls, root_dir: Optional[str], config: Optional[Union[str, Dict[str, Any], '[UtcpClientConfig](./data/utcp_client_config.md#utcpclientconfig)']]) -> 'UtcpClient'
+
+Create a new instance of UtcpClient.
+
+
+**Args**
+
+- **`root_dir`**: The root directory for the client to resolve relative paths from. Defaults to the current working directory.
+- **`config`**: The configuration for the client. Can be a path to a configuration file, a dictionary, or [UtcpClientConfig](./data/utcp_client_config.md#utcpclientconfig) object.
+- **`tool_repository`**: The tool repository to use. Defaults to [InMemToolRepository](./implementations/in_mem_tool_repository.md#inmemtoolrepository).
+- **`search_strategy`**: The tool search strategy to use. Defaults to TagSearchStrategy.
+
+
+
+**Returns**
+
+A new instance of UtcpClient.
+
+
+
+async register_manual(self, manual_call_template: [CallTemplate](./data/call_template.md#calltemplate)) -> [RegisterManualResult](./data/register_manual_response.md#registermanualresult)
+
+Register a tool [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The [CallTemplate](./data/call_template.md#calltemplate) to register.
+
+
+
+**Returns**
+
+A [RegisterManualResult](./data/register_manual_response.md#registermanualresult) object containing the registered [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+
+async register_manuals(self, manual_call_templates: List[[CallTemplate](./data/call_template.md#calltemplate)]) -> List[[RegisterManualResult](./data/register_manual_response.md#registermanualresult)]
+
+Register multiple tool CallTemplates and their tools.
+
+
+**Args**
+
+- **`manual_call_templates`**: List of CallTemplates to register.
+
+
+
+**Returns**
+
+A list of [RegisterManualResult](./data/register_manual_response.md#registermanualresult) objects containing the registered CallTemplates and their tools. Order is not preserved.
+
+
+
+async deregister_manual(self, manual_call_template_name: str) -> bool
+
+Deregister a tool [CallTemplate](./data/call_template.md#calltemplate).
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the [CallTemplate](./data/call_template.md#calltemplate) to deregister.
+
+
+
+**Returns**
+
+True if the [CallTemplate](./data/call_template.md#calltemplate) was deregistered, False otherwise.
+
+
+
+async call_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> Any
+
+Call a tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: The arguments to pass to the tool.
+
+
+
+**Returns**
+
+The result of the tool call.
+
+
+
+async call_tool_streaming(self, tool_name: str, tool_args: Dict[str, Any]) -> AsyncGenerator[Any, None]
+
+Call a tool streamingly.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: The arguments to pass to the tool.
+
+
+
+**Returns**
+
+An async generator that yields the result of the tool call.
+
+
+
+async search_tools(self, query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./data/tool.md#tool)]
+
+Search for tools relevant to the query.
+
+
+**Args**
+
+- **`query`**: The search query.
+- **`limit`**: The maximum number of tools to return. 0 for no limit.
+- **`any_of_tags_required`**: Optional list of tags where one of them must be present in the tool's tags
+
+
+
+**Returns**
+
+A list of tools that match the search query.
+
+
+
+async get_required_variables_for_manual_and_tools(self, manual_call_template: [CallTemplate](./data/call_template.md#calltemplate)) -> List[str]
+
+Get the required variables for a manual [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The manual [CallTemplate](./data/call_template.md#calltemplate).
+
+
+
+**Returns**
+
+A list of required variables for the manual [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+
+async get_required_variables_for_registered_tool(self, tool_name: str) -> List[str]
+
+Get the required variables for a registered tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of a registered tool.
+
+
+
+**Returns**
+
+A list of required variables for the tool.
+
+
+---
diff --git a/docs/api/index.md b/docs/api/index.md
new file mode 100644
index 0000000..ab895d5
--- /dev/null
+++ b/docs/api/index.md
@@ -0,0 +1,229 @@
+---
+title: UTCP API Reference
+sidebar_label: API Specification
+sidebar_position: 2
+---
+
+# UTCP API Reference
+
+API specification of a UTCP-compliant client implementation. Any implementation of a UTCP Client needs to have all of the classes, functions and fields described in this specification.
+
+This specification is organized by module of the reference python implementation to provide a comprehensive understanding of UTCP's architecture.
+
+**Note:** The modules don't have to be implemented in the same way as in the reference implementation, but all of the functionality here needs to be provided.
+
+**Total documented items:** 189
+**Modules documented:** 39
+
+## Core Modules
+
+Core UTCP framework components that define the fundamental interfaces and implementations.
+
+### [utcp.data.auth](./core\utcp\data\auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.api_key_auth](./core\utcp\data\auth_implementations\api_key_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.basic_auth](./core\utcp\data\auth_implementations\basic_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.oauth2_auth](./core\utcp\data\auth_implementations\oauth2_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.call_template](./core\utcp\data\call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.register_manual_response](./core\utcp\data\register_manual_response.md)
+
+- **Contains:** 1 classes
+
+
+### [utcp.data.tool](./core\utcp\data\tool.md)
+
+- **Contains:** 4 classes, 4 methods
+
+
+### [utcp.data.utcp_client_config](./core\utcp\data\utcp_client_config.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.utcp_manual](./core\utcp\data\utcp_manual.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.variable_loader](./core\utcp\data\variable_loader.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.data.variable_loader_implementations.dot_env_variable_loader](./core\utcp\data\variable_loader_implementations\dot_env_variable_loader.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.exceptions.utcp_serializer_validation_error](./core\utcp\exceptions\utcp_serializer_validation_error.md)
+
+- **Contains:** 1 classes
+
+
+### [utcp.exceptions.utcp_variable_not_found_exception](./core\utcp\exceptions\utcp_variable_not_found_exception.md)
+
+- **Contains:** 1 classes, 1 methods
+
+
+### [utcp.implementations.default_variable_substitutor](./core\utcp\implementations\default_variable_substitutor.md)
+
+- **Contains:** 1 classes, 2 methods
+
+
+### [utcp.implementations.in_mem_tool_repository](./core\utcp\implementations\in_mem_tool_repository.md)
+
+- **Contains:** 2 classes, 12 methods
+
+
+### [utcp.implementations.tag_search](./core\utcp\implementations\tag_search.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.implementations.utcp_client_implementation](./core\utcp\implementations\utcp_client_implementation.md)
+
+- **Contains:** 1 classes, 9 methods
+
+
+### [utcp.interfaces.communication_protocol](./core\utcp\interfaces\communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [utcp.interfaces.concurrent_tool_repository](./core\utcp\interfaces\concurrent_tool_repository.md)
+
+- **Contains:** 1 classes, 10 methods
+
+
+### [utcp.interfaces.serializer](./core\utcp\interfaces\serializer.md)
+
+- **Contains:** 1 classes, 3 methods
+
+
+### [utcp.interfaces.tool_post_processor](./core\utcp\interfaces\tool_post_processor.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.interfaces.tool_search_strategy](./core\utcp\interfaces\tool_search_strategy.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.interfaces.variable_substitutor](./core\utcp\interfaces\variable_substitutor.md)
+
+- **Contains:** 1 classes, 2 methods
+
+
+### [utcp.plugins.discovery](./core\utcp\plugins\discovery.md)
+
+- **Contains:** 7 functions
+
+
+### [utcp.plugins.plugin_loader](./core\utcp\plugins\plugin_loader.md)
+
+- **Contains:** 1 functions
+
+
+### [utcp.utcp_client](./core\utcp\utcp_client.md)
+
+- **Contains:** 1 classes, 9 methods
+
+
+## Plugin Modules
+
+Plugin implementations that extend UTCP with specific transport protocols and capabilities.
+
+### [communication_protocols.cli.src.utcp_cli.cli_call_template](./plugins\communication_protocols\cli\src\utcp_cli\cli_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.cli.src.utcp_cli.cli_communication_protocol](./plugins\communication_protocols\cli\src\utcp_cli\cli_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.http_call_template](./plugins\communication_protocols\http\src\utcp_http\http_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.http_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\http_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.openapi_converter](./plugins\communication_protocols\http\src\utcp_http\openapi_converter.md)
+
+- **Contains:** 1 classes, 1 methods
+
+
+### [communication_protocols.http.src.utcp_http.sse_call_template](./plugins\communication_protocols\http\src\utcp_http\sse_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.sse_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\sse_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.streamable_http_call_template](./plugins\communication_protocols\http\src\utcp_http\streamable_http_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.streamable_http_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\streamable_http_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.mcp.src.utcp_mcp.mcp_call_template](./plugins\communication_protocols\mcp\src\utcp_mcp\mcp_call_template.md)
+
+- **Contains:** 3 classes, 2 methods
+
+
+### [communication_protocols.mcp.src.utcp_mcp.mcp_communication_protocol](./plugins\communication_protocols\mcp\src\utcp_mcp\mcp_communication_protocol.md)
+
+- **Contains:** 1 classes, 3 methods
+
+
+### [communication_protocols.text.src.utcp_text.text_call_template](./plugins\communication_protocols\text\src\utcp_text\text_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.text.src.utcp_text.text_communication_protocol](./plugins\communication_protocols\text\src\utcp_text\text_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+## About UTCP
+
+The Universal Tool Calling Protocol (UTCP) is a framework for calling tools across various transport protocols.
+This API reference covers all the essential interfaces, implementations, and extension points needed to:
+
+- **Implement** new transport protocols
+- **Extend** UTCP with custom functionality
+- **Integrate** UTCP into your applications
+- **Understand** the complete UTCP architecture
\ No newline at end of file
diff --git a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
new file mode 100644
index 0000000..7fd7267
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
@@ -0,0 +1,62 @@
+---
+title: cli_call_template
+sidebar_label: cli_call_template
+---
+
+# cli_call_template
+
+**File:** `plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.py`
+
+### class CliCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#clicalltemplate}
+
+
+Documentation
+
+Call template configuration for Command Line Interface tools.
+
+Enables execution of command-line tools and programs as UTCP providers.
+Supports environment variable injection and custom working directories.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "cli" for CLI providers.
+- **`command_name`**: The name or path of the command to execute.
+- **`env_vars`**: Optional environment variables to set during command execution.
+- **`working_dir`**: Optional custom working directory for command execution.
+- **`auth`**: Always None - CLI providers don't support authentication.
+
+
+#### Fields:
+
+- call_template_type: Literal['cli']
+- command_name: str
+- env_vars: Optional[Dict[str, str]]
+- working_dir: Optional[str]
+- auth: None
+
+---
+
+### class CliCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[CliCallTemplate]) {#clicalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for CliCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: CliCallTemplate) -> dict
+
+Converts a CliCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> CliCallTemplate
+
+Validates a dictionary and returns a CliCallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
new file mode 100644
index 0000000..52ff158
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
@@ -0,0 +1,97 @@
+---
+title: cli_communication_protocol
+sidebar_label: cli_communication_protocol
+---
+
+# cli_communication_protocol
+
+**File:** `plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.py`
+
+### class CliCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#clicommunicationprotocol}
+
+
+Documentation
+
+Transport implementation for CLI-based tool providers.
+
+Handles communication with command-line tools by executing processes
+and managing their input/output. Supports both tool discovery and
+execution phases with comprehensive error handling and timeout management.
+
+
+**Features**
+
+- Asynchronous subprocess execution with proper cleanup
+- [Tool](./../../../../../core/utcp/data/tool.md#tool) discovery through startup commands returning UTCP manuals
+- Flexible argument formatting for various CLI conventions
+- Environment variable injection for authentication
+- JSON output parsing with graceful fallback to text
+- Cross-platform command parsing and execution
+- Configurable working directories and timeouts
+- Process lifecycle management with proper termination
+
+
+
+**Architecture**
+
+CLI tools are discovered by executing the provider's command_name
+and parsing the output for UTCP manual JSON. [Tool](./../../../../../core/utcp/data/tool.md#tool) calls execute
+the same command with formatted arguments and return processed output.
+
+
+
+**Attributes**
+
+- **`_log`**: Logger function for debugging and error reporting.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a CLI manual and discover its tools.
+
+Executes the call template's command_name and looks for a UTCP manual JSON in the output.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a CLI manual (no-op).
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a CLI tool.
+
+Executes the command specified by provider.command_name with the provided arguments.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call
+- **`tool_args`**: Arguments for the tool call
+- **`tool_call_template`**: The [CliCallTemplate](./cli_call_template.md#clicalltemplate) for the tool
+
+
+
+**The Output From The Command Execution Based On Exit Code**
+
+
+
+
+**Raises**
+
+- **`ValueError`**: If provider is not a CliProvider or command_name is not set
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming calls are not supported for CLI protocol.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
new file mode 100644
index 0000000..34f08cc
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
@@ -0,0 +1,71 @@
+---
+title: http_call_template
+sidebar_label: http_call_template
+---
+
+# http_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/http_call_template.py`
+
+### class HttpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#httpcalltemplate}
+
+
+Documentation
+
+Provider configuration for HTTP-based tools.
+
+Supports RESTful HTTP/HTTPS APIs with various HTTP methods, authentication,
+custom headers, and flexible request/response handling. Supports URL path
+parameters using {parameter_name} syntax. All tool arguments not mapped to
+URL body, headers or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "http" for HTTP providers.
+- **`http_method`**: The HTTP method to use for requests.
+- **`url`**: The base URL for the HTTP endpoint. Supports path parameters like
+ "https://api.example.com/users/{user_id}/posts/{post_id}".
+- **`content_type`**: The Content-Type header for requests.
+- **`auth`**: Optional authentication configuration.
+- **`headers`**: Optional static headers to include in all requests.
+- **`body_field`**: Name of the tool argument to map to the HTTP request body.
+- **`header_fields`**: List of tool argument names to map to HTTP request headers.
+
+
+#### Fields:
+
+- call_template_type: Literal['http']
+- http_method: Literal['GET', 'POST', 'PUT', 'DELETE', 'PATCH']
+- url: str
+- content_type: str
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- headers: Optional[Dict[str, str]]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class HttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[HttpCallTemplate]) {#httpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for HttpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: HttpCallTemplate) -> dict
+
+Convert HttpCallTemplate to dictionary.
+
+
+
+validate_dict(self, obj: dict) -> HttpCallTemplate
+
+Validate dictionary and convert to HttpCallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
new file mode 100644
index 0000000..9aa00c5
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
@@ -0,0 +1,108 @@
+---
+title: http_communication_protocol
+sidebar_label: http_communication_protocol
+---
+
+# http_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.py`
+
+### class HttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#httpcommunicationprotocol}
+
+
+Documentation
+
+HTTP communication protocol implementation for UTCP client.
+
+Handles communication with HTTP-based tool providers, supporting various
+authentication methods, URL path parameters, and automatic tool discovery.
+Enforces security by requiring HTTPS or localhost connections.
+
+
+**Features**
+
+- RESTful API communication with configurable HTTP methods
+- URL path parameter substitution from tool arguments
+- [Tool](./../../../../../core/utcp/data/tool.md#tool) discovery from UTCP manuals, OpenAPI specs, and YAML
+- Request body and header field mapping from tool arguments
+- OAuth2 token caching and automatic refresh
+- Security validation of connection URLs
+
+
+
+**Attributes**
+
+- **`_session`**: Optional aiohttp ClientSession for connection reuse.
+- **`_oauth_tokens`**: Cache of OAuth2 tokens by client_id.
+- **`_log`**: Logger function for debugging and error reporting.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to register.
+
+
+
+**Returns**
+
+[RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult) object containing the call template and manual.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a manual and its tools.
+
+Deregistering a manual is a no-op for the stateless HTTP communication protocol.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through this transport.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+The tool's response, with type depending on the tool's output schema.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through this transport streamingly.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+An async generator that yields the tool's response.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
new file mode 100644
index 0000000..ae243cc
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
@@ -0,0 +1,60 @@
+---
+title: openapi_converter
+sidebar_label: openapi_converter
+---
+
+# openapi_converter
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/openapi_converter.py`
+
+### class OpenApiConverter {#openapiconverter}
+
+
+Documentation
+
+Converts OpenAPI specifications into UTCP tool definitions.
+
+Processes OpenAPI 2.0 and 3.0 specifications to generate equivalent UTCP
+tools, handling schema resolution, authentication mapping, and proper
+HTTP call_template configuration. Each operation in the OpenAPI spec becomes
+a UTCP tool with appropriate input/output schemas.
+
+
+**Features**
+
+- Complete OpenAPI specification parsing
+- Recursive JSON reference ($ref) resolution
+- Authentication scheme conversion (API key, Basic, OAuth2)
+- Input parameter and request body handling
+- Response schema extraction
+- URL template and path parameter support
+- Provider name normalization
+- Placeholder variable generation for configuration
+
+
+
+**Architecture**
+
+The converter works by iterating through all paths and operations
+in the OpenAPI spec, extracting relevant information for each
+operation, and creating corresponding UTCP tools with HTTP call_templates.
+
+
+
+**Attributes**
+
+- **`spec`**: The parsed OpenAPI specification dictionary.
+- **`spec_url`**: Optional URL where the specification was retrieved from.
+- **`placeholder_counter`**: Counter for generating unique placeholder variables.
+- **`call_template_name`**: Normalized name for the call_template derived from the spec.
+
+
+#### Methods:
+
+
+convert(self) -> [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual)
+
+Parses the OpenAPI specification and returns a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
new file mode 100644
index 0000000..7949c20
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
@@ -0,0 +1,72 @@
+---
+title: sse_call_template
+sidebar_label: sse_call_template
+---
+
+# sse_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/sse_call_template.py`
+
+### class SseCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#ssecalltemplate}
+
+
+Documentation
+
+Provider configuration for Server-Sent Events (SSE) tools.
+
+Enables real-time streaming of events from server to client using the
+Server-Sent Events protocol. Supports automatic reconnection and
+event type filtering. All tool arguments not mapped to URL body, headers
+or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "sse" for SSE providers.
+- **`url`**: The SSE endpoint URL to connect to.
+- **`event_type`**: Optional filter for specific event types. If None, all events are received.
+- **`reconnect`**: Whether to automatically reconnect on connection loss.
+- **`retry_timeout`**: Timeout in milliseconds before attempting reconnection.
+- **`auth`**: Optional authentication configuration.
+- **`headers`**: Optional static headers for the initial connection.
+- **`body_field`**: Optional tool argument name to map to request body during connection.
+- **`header_fields`**: List of tool argument names to map to HTTP headers during connection.
+
+
+#### Fields:
+
+- call_template_type: Literal['sse']
+- url: str
+- event_type: Optional[str]
+- reconnect: bool
+- retry_timeout: int
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- headers: Optional[Dict[str, str]]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class SSECallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[SseCallTemplate]) {#ssecalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for SSECallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: SseCallTemplate) -> dict
+
+Converts a SSECallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> SseCallTemplate
+
+Validates a dictionary and returns a SSECallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
new file mode 100644
index 0000000..3cf186b
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
@@ -0,0 +1,46 @@
+---
+title: sse_communication_protocol
+sidebar_label: sse_communication_protocol
+---
+
+# sse_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.py`
+
+### class SseCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#ssecommunicationprotocol}
+
+
+Documentation
+
+SSE communication protocol implementation for UTCP client.
+
+Handles Server-Sent Events based tool providers with streaming capabilities.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools from an SSE provider.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister an SSE manual and close any active connections.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through SSE transport.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through SSE transport with streaming.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
new file mode 100644
index 0000000..6d2baf4
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
@@ -0,0 +1,74 @@
+---
+title: streamable_http_call_template
+sidebar_label: streamable_http_call_template
+---
+
+# streamable_http_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.py`
+
+### class StreamableHttpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#streamablehttpcalltemplate}
+
+
+Documentation
+
+Provider configuration for HTTP streaming tools.
+
+Uses HTTP Chunked Transfer Encoding to enable streaming of large responses
+or real-time data. Useful for tools that return large datasets or provide
+progressive results. All tool arguments not mapped to URL body, headers
+or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "streamable_http" for HTTP streaming providers.
+- **`url`**: The streaming HTTP endpoint URL. Supports path parameters.
+- **`http_method`**: The HTTP method to use (GET or POST).
+- **`content_type`**: The Content-Type header for requests.
+- **`chunk_size`**: Size of each chunk in bytes for reading the stream.
+- **`timeout`**: Request timeout in milliseconds.
+- **`headers`**: Optional static headers to include in requests.
+- **`auth`**: Optional authentication configuration.
+- **`body_field`**: Optional tool argument name to map to HTTP request body.
+- **`header_fields`**: List of tool argument names to map to HTTP request headers.
+
+
+#### Fields:
+
+- call_template_type: Literal['streamable_http']
+- url: str
+- http_method: Literal['GET', 'POST']
+- content_type: str
+- chunk_size: int
+- timeout: int
+- headers: Optional[Dict[str, str]]
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class StreamableHttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[StreamableHttpCallTemplate]) {#streamablehttpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for StreamableHttpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: StreamableHttpCallTemplate) -> dict
+
+Converts a StreamableHttpCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> StreamableHttpCallTemplate
+
+Validates a dictionary and returns a StreamableHttpCallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
new file mode 100644
index 0000000..f79daaf
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
@@ -0,0 +1,46 @@
+---
+title: streamable_http_communication_protocol
+sidebar_label: streamable_http_communication_protocol
+---
+
+# streamable_http_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.py`
+
+### class StreamableHttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#streamablehttpcommunicationprotocol}
+
+
+Documentation
+
+Streamable HTTP communication protocol implementation for UTCP client.
+
+Handles HTTP streaming with chunked transfer encoding for real-time data.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools from a StreamableHttp provider.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a StreamableHttp manual. This is a no-op for the stateless streamable HTTP protocol.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through StreamableHttp transport.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through StreamableHttp transport with streaming.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
new file mode 100644
index 0000000..e140b20
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
@@ -0,0 +1,85 @@
+---
+title: mcp_call_template
+sidebar_label: mcp_call_template
+---
+
+# mcp_call_template
+
+**File:** `plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.py`
+
+### class McpConfig {#mcpconfig}
+
+
+Documentation
+
+Implementing this class is not required!!!
+The McpCallTemplate just needs to support a MCP compliant server configuration.
+
+Configuration container for multiple MCP servers.
+
+Holds a collection of named MCP server configurations, allowing
+a single MCP provider to manage multiple server connections.
+
+
+**Attributes**
+
+- **`mcpServers`**: Dictionary mapping server names to their configurations.
+
+
+#### Fields:
+
+- mcpServers: Dict[str, Dict[str, Any]]
+
+---
+
+### class McpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#mcpcalltemplate}
+
+
+Documentation
+
+Provider configuration for Model Context Protocol (MCP) tools.
+
+Enables communication with MCP servers that provide structured tool
+interfaces. Supports both stdio (local process) and HTTP (remote)
+transport methods.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "mcp" for MCP providers.
+- **`config`**: Configuration object containing MCP server definitions.
+ This follows the same format as the official MCP server configuration.
+- **`auth`**: Optional OAuth2 authentication for HTTP-based MCP servers.
+
+
+#### Fields:
+
+- call_template_type: Literal['mcp']
+- config: McpConfig
+- auth: Optional[[OAuth2Auth](./../../../../../core/utcp/data/auth_implementations/oauth2_auth.md#oauth2auth)]
+
+---
+
+### class McpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[McpCallTemplate]) {#mcpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for McpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: McpCallTemplate) -> dict
+
+Convert McpCallTemplate to dictionary.
+
+
+
+validate_dict(self, obj: dict) -> McpCallTemplate
+
+Validate and convert dictionary to McpCallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
new file mode 100644
index 0000000..6f03a6d
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
@@ -0,0 +1,41 @@
+---
+title: mcp_communication_protocol
+sidebar_label: mcp_communication_protocol
+---
+
+# mcp_communication_protocol
+
+**File:** `plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.py`
+
+### class McpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#mcpcommunicationprotocol}
+
+
+Documentation
+
+MCP transport implementation that connects to MCP servers via stdio or HTTP.
+
+This implementation uses a session-per-operation approach where each operation
+(register, call_tool) opens a fresh session, performs the operation, and closes.
+
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual with the communication protocol.
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a tool using the model context protocol.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming calls are not supported for MCP protocol, so we just call the tool and return the result as one item.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
new file mode 100644
index 0000000..be893a1
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
@@ -0,0 +1,58 @@
+---
+title: text_call_template
+sidebar_label: text_call_template
+---
+
+# text_call_template
+
+**File:** `plugins/communication_protocols/text/src/utcp_text/text_call_template.py`
+
+### class TextCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#textcalltemplate}
+
+
+Documentation
+
+Call template for text file-based manuals and tools.
+
+Reads UTCP manuals or tool definitions from local JSON/YAML files. Useful for
+static tool configurations or environments where manuals are distributed as files.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "text" for text file call templates.
+- **`file_path`**: Path to the file containing the UTCP manual or tool definitions.
+- **`auth`**: Always None - text call templates don't support authentication.
+
+
+#### Fields:
+
+- call_template_type: Literal['text']
+- file_path: str
+- auth: None
+
+---
+
+### class TextCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[TextCallTemplate]) {#textcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for TextCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: TextCallTemplate) -> dict
+
+Convert a TextCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> TextCallTemplate
+
+Validate and convert a dictionary to a TextCallTemplate.
+
+
+---
diff --git a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
new file mode 100644
index 0000000..dc86311
--- /dev/null
+++ b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
@@ -0,0 +1,44 @@
+---
+title: text_communication_protocol
+sidebar_label: text_communication_protocol
+---
+
+# text_communication_protocol
+
+**File:** `plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.py`
+
+### class TextCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#textcommunicationprotocol}
+
+
+Documentation
+
+Communication protocol for file-based UTCP manuals and tools.
+
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a text manual and return its tools as a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+
+
+
+async deregister_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a text manual (no-op).
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a tool: for text templates, return file content from the configured path.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming variant: yields the full content as a single chunk.
+
+
+---
diff --git a/docs/for-tool-callers/for-tool-callers.md b/docs/for-tool-callers/for-tool-callers.md
deleted file mode 100644
index c5c36ba..0000000
--- a/docs/for-tool-callers/for-tool-callers.md
+++ /dev/null
@@ -1,298 +0,0 @@
----
-id: for-tool-callers
-title: For Tool Callers
-sidebar_position: 2
----
-
-# For Tool Callers
-
-This guide helps you discover and use UTCP tools in your applications, whether you're building an AI agent, a workflow automation system, or any other tool-consuming application.
-
-## The Discovery Process
-
-Using tools with UTCP follows this simple process:
-
-1. Connect to a tool provider's discovery endpoint
-2. Retrieve the `UTCPManual` containing available tools
-3. Register the tools in your client
-4. Call tools as needed using their native protocols
-
-## Using the UTCP Client
-
-The `utcp` package provides a ready-to-use client for discovering and calling tools. You can configure it with variables and even auto-load providers:
-
-```python
-import asyncio
-from utcp.client.utcp_client import UtcpClient
-from utcp.shared.provider import HttpProvider
-
-async def main():
- # Create a UTCP client
- client = UtcpClient()
-
- # Define the provider
- provider = HttpProvider(
- name="weather_api",
- provider_type="http",
- url="https://api.example.com/utcp",
- http_method="GET"
- )
-
- # Register tools from the provider
- tools = await client.register_tool_provider(provider)
- print(f"Registered {len(tools)} tools from {provider.name}")
-
- # Call a tool with arguments
- result = await client.call_tool("weather_api.get_weather", arguments={"location": "San Francisco"})
- print(f"Weather: {result['temperature']}°C, {result['conditions']}")
-
-if __name__ == "__main__":
- asyncio.run(main())
-```
-
-## Integrating with Large Language Models (LLMs)
-
-The `UtcpClient` is designed to be easily integrated into applications that use Large Language Models (LLMs) for function calling. For a complete example of how to use `UtcpClient` with an LLM like OpenAI's GPT, see the example file below:
-
-- [Full LLM Example with OpenAI](https://github.com/universal-tool-calling-protocol/python-utcp/blob/main/example/src/full_llm_example/openai_utcp_example.py)
-
-This example demonstrates how to wrap the `UtcpClient` to make its tools available to an LLM, handle tool calls from the model, and return the results.
-
-## Tool Namespacing
-
-UTCP uses a simple namespacing convention to avoid name conflicts:
-
-```
-provider_name.tool_name
-```
-
-For example, if a provider named "weather_api" offers a tool named "get_forecast", you would call it using `weather_api.get_forecast`.
-
-## Understanding Tool Definitions
-
-When you register a provider, you receive tool definitions that include:
-
-1. **Name and Description**: What the tool is and what it does
-2. **Input Schema**: The parameters the tool accepts
-3. **Output Schema**: The structure of the tool's response
-4. **Provider Information**: How to call the tool directly
-
-Here's what a typical tool definition looks like:
-
-```json
-{
- "name": "get_weather",
- "description": "Get current weather for a location",
- "inputs": {
- "type": "object",
- "properties": {
- "location": {
- "type": "string",
- "description": "City name"
- }
- },
- "required": ["location"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "temperature": {"type": "number"},
- "conditions": {"type": "string"}
- }
- },
- "tool_provider": {
- "name": "weather_api",
- "provider_type": "http",
- "url": "https://api.example.com/api/weather",
- "http_method": "GET"
- }
-}
-```
-
-## Error Handling Best Practices
-
-When working with UTCP tools, implement these error handling strategies:
-
-1. **Provider Registration Errors**:
- - Retry with exponential backoff for transient network issues
- - Cache previously discovered tools to maintain functionality when possible
- - Provide clear error messages when a provider is unavailable
-
-2. **Tool Calling Errors**:
- - Validate inputs against the tool's schema before calling
- - Handle HTTP status codes and provider-specific errors
- - Implement timeouts and retry logic for unreliable tools
-
-```python
-try:
- result = await client.call_tool("weather_api.get_weather", arguments={"location": "San Francisco"})
-except UTCPProviderError as e:
- print(f"Provider error: {e}")
-except UTCPToolNotFoundError as e:
- print(f"Tool not found: {e}")
-except UTCPValidationError as e:
- print(f"Invalid parameters: {e}")
-```
-
-## Working with Different Provider Types
-
-UTCP supports multiple [provider types](providers), and the client handles the protocol differences for you:
-
-- **HTTP providers**: RESTful API calls
-- **WebSocket providers**: Real-time bidirectional communication
-- **CLI providers**: Local command-line tool execution
-- **SSE providers**: Server-sent events for streaming responses
-- **Other provider types**: Other provider types in the [Providers](providers) section
-
-The `UTCPClient` automatically uses the appropriate protocol based on its `tool_provider` configuration.
-
-## Provider Types: Manual vs. Tool
-
-It's important to understand the distinction between two types of providers in UTCP:
-
-1. **Manual Provider**: This is the provider that a `UtcpClient` connects to for **tool discovery**. Its responsibility is to return a `UTCPManual` object (or an OpenAPI specification that can be converted into one). It defines an endpoint for discovery but doesn't execute the tools themselves. You register these with the client.
-
-2. **Tool Provider**: This provider is defined *inside* each `Tool` object within the `UTCPManual`. Its purpose is to provide the specific connection and configuration details needed to **execute that one tool**. The `tool_provider` field contains all the information a client needs to make a call, such as the URL, HTTP method, or command-line arguments.
-
-When you register a provider with the `UtcpClient`, you are registering a **manual provider**. The client will then use the **tool providers** it discovers in the manual to execute the individual tools.
-
-## Advanced Usage
-
-### Authentication
-
-The UTCP client supports various authentication methods through provider configuration:
-
-```python
-from utcp.client.utcp_client import UtcpClient
-from utcp.shared.provider import HttpProvider
-
-client = UtcpClient()
-
-# API Key authentication
-provider_with_api_key = HttpProvider(
- name="weather_api",
- provider_type="http",
- url="https://api.example.com/utcp",
- http_method="GET",
- auth={
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "X-API-Key"
- }
-)
-
-# OAuth2 authentication
-provider_with_oauth = HttpProvider(
- name="translation_api",
- provider_type="http",
- url="https://translate.example.com/utcp",
- http_method="GET",
- auth={
- "auth_type": "oauth2",
- "client_id": "$YOUR_CLIENT_ID",
- "client_secret": "$YOUR_CLIENT_SECRET",
- "token_url": "https://auth.example.com/token"
- }
-)
-
-# Register both providers
-await client.register_tool_provider(provider_with_api_key)
-await client.register_tool_provider(provider_with_oauth)
-```
-
-### Client Configuration
-
-For more complex applications, you can configure the `UtcpClient` using a configuration object. This allows you to externalize provider definitions and manage variables more effectively.
-
-You can initialize the client by passing configuration parameters directly:
-
-```python
-from utcp.client.utcp_client import UtcpClient
-
-# Initialize client with configuration parameters
-client = await UtcpClient.create(
- providers_file_path="providers.json",
- load_variables_from=[
- {"type": "dotenv", "env_file_path": ".env"}
- ]
-)
-
-# Tools are loaded automatically from the providers file
-await client.load_tools_from_providers()
-```
-
-#### Provider Configuration File (`providers.json`)
-
-The `providers_file_path` points to a JSON file containing a list of manual provider configurations. This allows you to manage your providers without hardcoding them in your application.
-
-Example `providers.json`:
-
-```json
-[
- {
- "name": "weather_api",
- "provider_type": "http",
- "url": "https://api.example.com/utcp",
- "http_method": "GET",
- "auth": {
- "auth_type": "api_key",
- "api_key": "$WEATHER_API_KEY",
- "var_name": "X-API-Key"
- }
- }
-]
-```
-
-#### Variable Management and Substitution
-
-The `load_variables_from` option allows you to load variables from external sources, such as a `.env` file. The client will automatically substitute variables in your provider configurations.
-
-- Values prefixed with `$` (like `$API_KEY`) or enclosed as `${VAR_NAME}` will be replaced.
-- The client looks for matching variables in the configuration and then in environment variables.
-- If a variable isn't found, the client raises an error.
-
-Example `.env` file:
-
-```
-WEATHER_API_KEY="your-secret-api-key"
-```
-
-This approach helps keep your secrets and other configuration values secure and separate from your codebase.
-
-### Working with Multiple Providers
-
-You can register and use multiple providers in the same client:
-
-```python
-# Register multiple providers
-providers = [
- HttpProvider(name="weather_api", provider_type="http", url="https://weather.example.com/utcp", http_method="GET"),
- HttpProvider(name="translate_api", provider_type="http", url="https://translate.example.com/utcp", http_method="GET"),
- HttpProvider(name="image_api", provider_type="http", url="https://image.example.com/utcp", http_method="GET")
-]
-
-for provider in providers:
- tools = await client.register_tool_provider(provider)
- print(f"Registered {len(tools)} tools from {provider.name}")
-
-# Access tools from different providers
-weather = await client.call_tool("weather_api.get_forecast", arguments={"location": "Tokyo"})
-translation = await client.call_tool("translate_api.translate", arguments={"text": "Hello", "target": "fr"})
-```
-
-### Deregistering Providers
-
-You can deregister providers when they're no longer needed:
-
-```python
-# Deregister a provider by name
-await client.deregister_tool_provider("weather_api")
-```
-
-### Advanced Customization
-
-The `UtcpClient` is designed to be extensible. For advanced use cases, you can replace its core components with your own custom implementations.
-
-- **Custom Tool Repositories**: By default, the client stores tools in memory. If you need to persist discovered tools in a database or a file-based cache, you can implement a custom `ToolRepository`. Learn more in the [Tool Repositories](./client/tool-repository) guide.
-
-- **Custom Tool Search Strategies**: The default search strategy uses tag and description matching. If you need more sophisticated search capabilities, such as semantic search or integration with a vector database, you can implement a custom `ToolSearchStrategy`. Learn more in the [Tool Search Strategies](./client/tool-search-strategy) guide.
diff --git a/docs/for-tool-callers/tool-repository.md b/docs/for-tool-callers/tool-repository.md
deleted file mode 100644
index 69a237c..0000000
--- a/docs/for-tool-callers/tool-repository.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-id: tool-repository
-title: Tool Repositories
-sidebar_position: 1
----
-
-# Tool Repositories
-
-The `ToolRepository` is a key component of the `UtcpClient` responsible for storing, managing, and retrieving discovered tools and their associated providers.
-
-## The Role of a Tool Repository
-
-When you register a manual provider with the client, the client fetches the `UTCPManual` and uses the `ToolRepository` to save all the discovered tools. When you later call a tool, the client queries the repository to find the tool's definition and its `tool_provider` configuration.
-
-This abstraction allows you to control how and where tools are stored. You can use the default in-memory repository for simplicity or implement a custom repository for more advanced use cases like persistent storage.
-
-## Default Implementation: `InMemToolRepository`
-
-By default, the `UtcpClient` uses the `InMemToolRepository`, which stores all tools and providers in memory. This is suitable for most applications, especially those where the client's lifecycle is short-lived.
-
-**Characteristics:**
-- **Simple**: No external dependencies or configuration required.
-- **Fast**: All operations are performed in memory.
-- **Volatile**: All discovered tools are lost when the client instance is destroyed.
-
-## Creating a Custom Tool Repository
-
-For scenarios requiring persistence, you can create your own repository by inheriting from the `ToolRepository` abstract base class and implementing its methods. This is useful if you want to cache discovered tools in a database, a file, or a distributed cache to avoid re-fetching them every time your application starts.
-
-### Example: A Custom JSON File Repository
-
-Here is a simplified example of a repository that persists tools to a local JSON file.
-
-```python
-import json
-from typing import List, Dict, Optional
-from utcp.shared.provider import Provider
-from utcp.shared.tool import Tool
-from utcp.client.tool_repository import ToolRepository
-
-class JsonFileToolRepository(ToolRepository):
- def __init__(self, file_path: str):
- self.file_path = file_path
- self._data = self._load()
-
- def _load(self) -> Dict:
- try:
- with open(self.file_path, 'r') as f:
- return json.load(f)
- except (FileNotFoundError, json.JSONDecodeError):
- return {"providers": {}, "tools": []}
-
- def _save(self):
- with open(self.file_path, 'w') as f:
- json.dump(self._data, f, indent=2)
-
- async def save_provider_with_tools(self, provider: Provider, tools: List[Tool]):
- provider_name = provider.name
- self._data["providers"][provider_name] = provider.model_dump()
- # Ensure no duplicate tools are added
- existing_tool_names = {t['name'] for t in self._data['tools']}
- for tool in tools:
- if tool.name not in existing_tool_names:
- self._data["tools"].append(tool.model_dump())
- self._save()
-
- # ... implement other abstract methods (get_tool, get_providers, etc.) ...
-
-```
-
-### Using Your Custom Repository
-
-You can then instruct the `UtcpClient` to use your custom repository during instantiation:
-
-```python
-from utcp.client.utcp_client import UtcpClient
-
-# Instantiate your custom repository
-json_repo = JsonFileToolRepository("my_tools.json")
-
-# Pass it to the client
-client = await UtcpClient.create(tool_repository=json_repo)
-
-# Now, when you register providers, tools will be saved to 'my_tools.json'
-await client.register_tool_provider(...)
-```
diff --git a/docs/for-tool-callers/tool-search-strategy.md b/docs/for-tool-callers/tool-search-strategy.md
deleted file mode 100644
index 7306a29..0000000
--- a/docs/for-tool-callers/tool-search-strategy.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-id: tool-search-strategy
-title: Tool Search Strategies
-sidebar_position: 2
----
-
-# Tool Search Strategies
-
-The `ToolSearchStrategy` is a component of the `UtcpClient` that allows you to control how tools are searched and ranked based on a query. This is particularly useful for AI agents that need to find the most relevant tool for a given task.
-
-## The Role of a Tool Search Strategy
-
-When you call `client.search_tools(query)`, the client delegates the search operation to the configured `ToolSearchStrategy`. The strategy's job is to take the search query, compare it against the tools available in the `ToolRepository`, and return a ranked list of the most relevant `Tool` objects.
-
-This abstraction enables you to implement sophisticated search algorithms tailored to your specific needs, such as keyword matching, semantic search, or even AI-powered ranking.
-
-## Default Implementation: `TagSearchStrategy`
-
-The `UtcpClient` comes with a default search strategy called `TagSearchStrategy`. This strategy scores tools based on a simple but effective algorithm:
-
-1. It tokenizes the search query into individual words.
-2. It compares these words against each tool's `tags` and `description`.
-3. Matches with `tags` are given a higher weight than matches with the `description`.
-4. Tools are ranked by their total score and returned to the caller.
-
-This provides a good baseline for tool discovery without requiring complex setup.
-
-## Creating a Custom Tool Search Strategy
-
-You can implement a custom search strategy by inheriting from the `ToolSearchStrategy` abstract base class and implementing the `search_tools` method. This allows you to integrate with more advanced search technologies, such as vector databases or full-text search engines.
-
-### Example: A Custom Semantic Search Strategy
-
-Here is a conceptual example of a strategy that uses a sentence transformer model to perform semantic search. This would require a library like `sentence-transformers`.
-
-```python
-from typing import List
-from utcp.shared.tool import Tool
-from utcp.client.tool_repository import ToolRepository
-from utcp.client.tool_search_strategy import ToolSearchStrategy
-from sentence_transformers import SentenceTransformer, util
-
-class SemanticSearchStrategy(ToolSearchStrategy):
- def __init__(self, tool_repository: ToolRepository):
- self.tool_repository = tool_repository
- self.model = SentenceTransformer('all-MiniLM-L6-v2')
-
- async def search_tools(self, query: str, limit: int = 10) -> List[Tool]:
- tools = await self.tool_repository.get_tools()
- if not tools:
- return []
-
- # Create embeddings for the query and all tool descriptions
- query_embedding = self.model.encode(query, convert_to_tensor=True)
- tool_descriptions = [tool.description for tool in tools]
- description_embeddings = self.model.encode(tool_descriptions, convert_to_tensor=True)
-
- # Compute cosine similarity between the query and all descriptions
- cosine_scores = util.cos_sim(query_embedding, description_embeddings)[0]
-
- # Rank tools based on similarity scores
- top_results = sorted(zip(cosine_scores, tools), key=lambda x: x[0], reverse=True)
-
- # Return the top N tools
- return [tool for score, tool in top_results[:limit]]
-
-```
-
-### Using Your Custom Search Strategy
-
-You can configure the `UtcpClient` to use your custom strategy during instantiation:
-
-```python
-from utcp.client import UtcpClient
-
-# Instantiate your custom strategy
-semantic_search = SemanticSearchStrategy(client.tool_repository)
-
-# Pass it to the client
-client = await UtcpClient.create(search_strategy=semantic_search)
-
-# Now, client.search_tools() will use your semantic search logic
-relevant_tools = await client.search_tools("Find a way to send a message to a user")
-```
diff --git a/docs/for-tool-providers.md b/docs/for-tool-providers.md
deleted file mode 100644
index c79f345..0000000
--- a/docs/for-tool-providers.md
+++ /dev/null
@@ -1,284 +0,0 @@
----
-id: for-tool-providers
-title: For Tool Providers
-sidebar_position: 3
----
-
-# For Tool Providers
-
-This guide helps you expose your tools through UTCP so they can be discovered and used by AI agents and other applications.
-
-## Creating a UTCP Manual
-
-A UTCP Manual is the standardized description of your tools. To create one, you need to define:
-
-1. Your tools and their capabilities
-2. The provider information for calling those tools
-
-### The `UTCPManual` Structure
-
-Your discovery endpoint should return a `UTCPManual` object with the following structure:
-
-```json
-{
- "version": "1.0",
- "tools": [
- {
- "name": "tool_name",
- "description": "tool_description",
- "inputs": { ... },
- "outputs": { ... },
- "tags": ["tag"],
- "tool_provider": { ... }
- }
- ]
-}
-```
-
-### Fields
-
-| Field | Description |
-|-------|-------------|
-| `version` | The version of the UTCP protocol being used |
-| `tools` | A list of `Tool` objects representing available tools |
-
-:::important
-Tool discovery endpoints should be accessible at a consistent path, preferably `/utcp` for HTTP-based providers.
-:::
-
-## Tool Definition
-
-Each tool in your manual should be defined by a `Tool` object:
-
-```json
-{
- "name": "tool_name",
- "description": "tool_description",
- "inputs": {
- "type": "object",
- "properties": { ... },
- "required": ["string"],
- "description": "parameters_description",
- "title": "parameters"
- },
- "outputs": { ... },
- "tags": ["string"],
- "average_response_size": 200,
- "provider": { ... }
-}
-```
-
-### Fields
-
-| Field | Description |
-|-------|-------------|
-| `name` | The name of the tool (should be unique within your provider) |
-| `description` | A clear, concise description of what the tool does |
-| `inputs` | A schema defining the input parameters (follows simplified JSON Schema) |
-| `outputs` | A schema defining the output format (follows simplified JSON Schema) |
-| `tags` | Optional list of tags for categorization and search |
-| `average_response_size` | Optional integer indicating the estimated average number of tokens returned by this tool |
-| `tool_provider` | A `Provider` object that describes how to connect to and use the tool |
-
-### Input and Output Schemas
-
-Both `inputs` and `outputs` use a simplified JSON Schema format:
-
-```json
-{
- "type": "object",
- "properties": {
- "param1": {
- "type": "string",
- "description": "Description of parameter 1"
- },
- "param2": {
- "type": "integer",
- "description": "Description of parameter 2"
- }
- },
- "required": ["param1"],
- "description": "Overall description of the input/output",
- "title": "Optional title"
-}
-```
-
-### Best Practices for Tool Definitions
-
-1. **Clear Descriptions**: Provide clear, concise descriptions for both tools and parameters
-2. **Precise Types**: Use the most specific schema types to help clients validate inputs
-3. **Required Fields**: Explicitly list all required parameters
-4. **Complete Output Schemas**: Define output schemas thoroughly to help clients parse responses
-5. **Meaningful Names**: Use descriptive, action-oriented names for tools (e.g., `get_weather`, `translate_text`)
-6. **Logical Tags**: Use tags to group related tools and aid in discovery
-
-## Generating Tools from an OpenAPI Specification
-
-If you already have an OpenAPI (formerly Swagger) specification for your API, you can automatically generate a `UTCPManual` using the `OpenApiConverter` utility. This saves you from having to manually define each tool.
-
-### Using the Converter
-
-The converter takes an OpenAPI specification in JSON format and produces a `UTCPManual` object. Here's how you can use it in your discovery endpoint:
-
-```python
-import json
-from fastapi import FastAPI
-from utcp.client.openapi_converter import OpenApiConverter
-
-app = FastAPI()
-
-# Load your OpenAPI specification from a file
-with open("openapi.json", "r") as f:
- openapi_spec = json.load(f)
-
-@app.get("/utcp")
-def utcp_discovery():
- # Convert the OpenAPI spec to a UTCP manual
- converter = OpenApiConverter(openapi_spec)
- utcp_manual = converter.convert()
- return utcp_manual
-```
-
-### How it Works
-
-The `OpenApiConverter` maps OpenAPI concepts to UTCP tool definitions:
-
-- **Paths and Methods**: Each combination of a path (e.g., `/users/{id}`) and an HTTP method (`GET`, `POST`, etc.) becomes a separate tool.
-- **Operation ID**: The `operationId` from the OpenAPI operation is used as the tool's name.
-- **Summary and Description**: The `summary` and `description` fields are used for the tool's description.
-- **Parameters**: Request parameters (path, query, header, cookie) are mapped to the tool's `inputs` schema.
-- **Request Body**: The `requestBody` is also mapped to the tool's `inputs` schema.
-- **Responses**: The successful response (typically `200` or `201`) is mapped to the tool's `outputs` schema.
-- **Security Schemes**: The converter automatically detects security schemes (API Key, Basic Auth, OAuth2) and includes the appropriate `auth` configuration in the provider definition. It will even generate placeholder variables for secrets (e.g., `$PROVIDER_API_KEY`).
-
-By using the converter, you can quickly expose your existing API as a set of UTCP tools with minimal effort.
-
-## Provider Types: Manual vs. Tool
-
-It's important to understand the distinction between two types of providers in UTCP:
-
-1. **Manual Provider**: This is the provider that a `UtcpClient` connects to for **tool discovery**. Its responsibility is to return a `UTCPManual` object (or an OpenAPI specification that can be converted into one). It defines an endpoint for discovery but doesn't execute the tools themselves.
-
-2. **Tool Provider**: This provider is defined *inside* each `Tool` object within the `UTCPManual`. Its purpose is to provide the specific connection and configuration details needed to **execute that one tool**. The `tool_provider` field contains all the information a client needs to make a call, such as the URL, HTTP method, or command-line arguments.
-
-In simple cases, a single service might act as both a manual provider (at its discovery endpoint) and a tool provider (for the tools it offers). In more complex scenarios, a manual provider could return a manual listing tools from many different tool providers.
-
-## Tool Provider Configuration
-
-The provider object tells clients how to call your tool:
-
-```json
-{
- "name": "provider_name",
- "provider_type": "http",
- ... (protocol-specific attributes)
-}
-```
-
-### Variable Substitution
-
-You can use variables in your provider configuration by prefixing values with `$` or enclosing them in `${...}`. These variables will be replaced with values from the client's configuration or environment variables when the tool is called.
-
-```json
-{
- "auth": {
- "auth_type": "api_key",
- "api_key": "$API_KEY",
- "var_name": "X-API-Key"
- }
-}
-```
-
-You can also use the `${VAR}` syntax for more complex strings:
-
-```json
-{
- "url": "https://${DOMAIN}/api/v1/endpoint"
-}
-```
-
-:::note
-Make sure your tool definitions are accurate and complete.
-:::
-
-:::warning
-Make sure to document which variables users need to set in their environment or configuration.
-:::
-
-For details on provider-specific configuration, see the dedicated pages for each type:
-
-- [HTTP Provider](providers/http)
-- [HTTP Stream Provider](providers/http-stream)
-- [Server-Sent Events (SSE) Provider](providers/sse)
-- [WebSocket Provider](providers/websocket)
-- [gRPC Provider](providers/grpc)
-- [GraphQL Provider](providers/graphql)
-- [Command-Line (CLI) Provider](providers/cli)
-- [Model Context Protocol (MCP) Provider](providers/mcp)
-- [Text File Provider](providers/text)
-- [TCP Provider](providers/tcp)
-- [UDP Provider](providers/udp)
-- [WebRTC Provider](providers/webrtc)
-
-## Implementing a Discovery Endpoint
-
-For HTTP-based providers, implement a discovery endpoint at `/utcp` that returns your UTCP Manual:
-
-```python
-from fastapi import FastAPI
-from pydantic import BaseModel
-from typing import List, Dict, Any
-
-app = FastAPI()
-
-class UTCPManual(BaseModel):
- version: str
- tools: List[Dict[str, Any]]
-
-@app.get("/utcp")
-def utcp_discovery():
- return UTCPManual(
- version="1.0",
- tools=[
- {
- "name": "get_weather",
- "description": "Get current weather for a location",
- "inputs": {
- "type": "object",
- "properties": {
- "location": {
- "type": "string",
- "description": "City name"
- }
- },
- "required": ["location"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "temperature": {"type": "number"},
- "conditions": {"type": "string"}
- }
- },
- "provider": {
- "name": "weather_api",
- "provider_type": "http",
- "url": "https://api.example.com/api/weather",
- "http_method": "GET"
- },
- "tags": ["weather", "current"],
- "average_response_size": 150
- }
- ]
- )
-```
-
-## Testing Your UTCP Manual
-
-To ensure your UTCP Manual is valid and functional:
-
-1. Validate the JSON against the UTCP schema
-2. Test with the `utcp` command-line tool: `utcp test --url https://your-api.com/utcp`
-3. Try registering with a UTCP client and calling your tools
-
-For more detailed implementation guidance, see the [Implementation](implementation) page.
diff --git a/docs/implementation.md b/docs/implementation.md
deleted file mode 100644
index 5828b4e..0000000
--- a/docs/implementation.md
+++ /dev/null
@@ -1,153 +0,0 @@
----
-id: implementation
-title: Implementation Guide
-sidebar_position: 7
----
-
-# Implementation Guide
-
-This guide will walk you through the process of implementing UTCP in your applications, whether you're creating a tool provider or developing a client that consumes tools.
-
-## Overview
-
-Implementing UTCP typically involves one or both of the following:
-
-1. **Creating a Tool Provider**: Exposing your tools through a UTCP-compliant discovery endpoint
-2. **Building a UTCP Client**: Consuming tools from UTCP providers
-
-## Creating a Tool Provider
-
-A UTCP tool provider exposes one or more tools through a standardized discovery endpoint. Here's how to implement one:
-
-### Step 1: Define Your Tools
-
-First, define the tools you want to expose using the UTCP `Tool` model:
-
-```python
-tools = [
- {
- "name": "get_weather",
- "description": "Get the current weather for a location",
- "inputs": {
- "type": "object",
- "properties": {
- "location": {
- "type": "string",
- "description": "The city and state, e.g. San Francisco, CA"
- },
- "unit": {
- "type": "string",
- "description": "The unit of temperature (celsius or fahrenheit)",
- "enum": ["celsius", "fahrenheit"]
- }
- },
- "required": ["location"],
- "description": "Weather query parameters"
- },
- "outputs": {
- "type": "object",
- "properties": {
- "temperature": {
- "type": "number",
- "description": "The current temperature"
- },
- "conditions": {
- "type": "string",
- "description": "The weather conditions (e.g., sunny, cloudy)"
- }
- },
- "required": ["temperature", "conditions"],
- "description": "Weather information"
- },
- "tags": ["weather", "api"],
- "tool_provider": {
- "provider_type": "http",
- "url": "https://api.example.com/weather",
- "http_method": "GET"
- }
- }
-]
-```
-
-### Step 2: Create a Discovery Endpoint
-
-Create an endpoint that returns a `UTCPManual` containing your tool definitions:
-
-```python
-from fastapi import FastAPI
-from pydantic import BaseModel
-from typing import List
-
-app = FastAPI()
-
-class UTCPManual(BaseModel):
- version: str
- tools: List[dict]
-
-@app.get("/utcp")
-def utcp_discovery():
- return UTCPManual(
- version="1.0",
- tools=tools
- )
-```
-
-### Step 3: Implement Tool Functionality
-
-Implement the actual functionality of each tool according to its provider specification. For example, for an HTTP provider:
-
-```python
-@app.get("/weather")
-def get_weather(location: str, unit: str = "celsius"):
- # Implement your weather logic here
- return {
- "temperature": 22.5,
- "conditions": "Sunny"
- }
-```
-
-## Using a UTCP Client
-
-Here's how you might use a UTCP client:
-
-```python
-import asyncio
-from utcp.client import UtcpClient
-from utcp.shared.provider import HttpProvider
-
-async def main():
- # Create a client
- client = await UtcpClient.create()
-
- # Define the manual provider for the discovery endpoint
- manual_provider = HttpProvider(
- name="weather_api",
- provider_type="http",
- url="https://api.example.com/utcp",
- http_method="GET"
- )
-
- # Register tools from the manual provider
- await client.register_manual_provider(manual_provider)
-
- # Call a tool
- result = await client.call_tool(
- "weather_api.get_weather",
- arguments={"location": "San Francisco"}
- )
- print(f"The temperature is {result['temperature']}°C and it's {result['conditions']}")
-
-# Run the example
-if __name__ == "__main__":
- asyncio.run(main())
-```
-
-## Best Practices
-
-When implementing UTCP:
-
-1. **Cache tool discoveries** to reduce load and handle temporary outages
-2. **Validate inputs** against the tool's input schema before sending
-3. **Handle errors gracefully**, especially for network-related issues
-4. **Implement timeouts** to prevent hanging on unresponsive tools
-5. **Log tool usage** for debugging and monitoring
diff --git a/docs/index.md b/docs/index.md
index 6c4d440..d7f0aae 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -4,17 +4,18 @@ title: Introduction
sidebar_position: 1
---
-# Introduction to UTCP
+# Introduction to UTCP 1.0
-The Universal Tool Calling Protocol (UTCP) is a modern, flexible, and scalable standard for defining and interacting with tools across a wide variety of communication protocols.
+The Universal Tool Calling Protocol (UTCP) is a lightweight, secure, and scalable standard for defining and interacting with tools across a wide variety of communication protocols. Version 1.0 introduces a modular core with a plugin-based architecture, making it more extensible, testable, and easier to package.
## Core Components
-UTCP consists of three main components:
+UTCP consists of four main components:
-1. **Manuals**: The standard description format that contains tool definitions
-2. **Tools**: The individual capabilities that can be called
-3. **Providers**: The communication channels through which tools and manuals are accessed
+1. [**Manuals**](./api/core/utcp/data/utcp_manual.md): The standard tool provider description format that contains tool definitions
+2. [**Tools**](./api/core/utcp/data/tool.md): The individual capabilities that can be called
+3. [**Call Templates**](./api/core/utcp/data/call_template.md): The communication configurations that specify how tools are accessed. Concretely this maps a tool name and provided arguments to an actual API request in a communication protocol.
+4. [**UtcpClient**](./api/core/utcp/utcp_client.md): The client that calls tools using the call templates.
## The "Manual" Approach
@@ -26,6 +27,23 @@ A UTCP Manual tells an agent: "Here is a tool. Here is its native endpoint (HTTP
This approach eliminates the need for wrapper servers and allows direct communication between agents and tools.
+## New Architecture in 1.0
+
+UTCP has been refactored into a core library and a set of optional plugins:
+
+### Core Package (`utcp`)
+- **Data Models**: Pydantic models for [`Tool`](./api/core/utcp/data/tool.md), [`CallTemplate`](./api/core/utcp/data/call_template.md), [`UtcpManual`](./api/core/utcp/data/utcp_manual.md), and [`Auth`](./api/core/utcp/data/auth.md)
+- **Pluggable Interfaces**: [`CommunicationProtocol`](./api/core/utcp/interfaces/communication_protocol.md), [`ConcurrentToolRepository`](./api/core/utcp/interfaces/concurrent_tool_repository.md), [`ToolSearchStrategy`](./api/core/utcp/interfaces/tool_search_strategy.md), [`VariableSubstitutor`](./api/core/utcp/interfaces/variable_substitutor.md), [`ToolPostProcessor`](./api/core/utcp/interfaces/tool_post_processor.md)
+- **Default Implementations**: [`UtcpClient`](./api/core/utcp/utcp_client.md), [`InMemToolRepository`](./api/core/utcp/implementations/in_mem_tool_repository.md), [`TagAndDescriptionWordMatchStrategy`](./api/core/utcp/implementations/tag_search.md)
+
+### Protocol Plugins
+- `utcp-http`: Supports HTTP, SSE, and streamable HTTP, plus an OpenAPI converter
+- `utcp-cli`: For wrapping local command-line tools
+- `utcp-mcp`: For interoperability with the Model Context Protocol (MCP)
+- `utcp-text`: For reading text files
+- `utcp-socket`: TCP and UDP protocols (work in progress)
+- `utcp-gql`: GraphQL (work in progress)
+
## Minimal Example
Let's see how easy it is to use UTCP with a minimal example.
@@ -43,7 +61,8 @@ app = FastAPI()
@app.get("/utcp")
def utcp_discovery():
return {
- "version": "1.0",
+ "manual_version": "1.0.0",
+ "utcp_version": "1.0.1",
"tools": [
{
"name": "get_weather",
@@ -65,8 +84,8 @@ def utcp_discovery():
"conditions": {"type": "string"}
}
},
- "tool_provider": {
- "provider_type": "http",
+ "call_template": {
+ "call_template_type": "http",
"url": "https://example.com/api/weather",
"http_method": "GET"
}
@@ -92,29 +111,27 @@ uvicorn app:app --reload
```python
# client.py
import asyncio
-from utcp.client.utcp_client import UtcpClient
-from utcp.shared.provider import HttpProvider
+from utcp.utcp_client import UtcpClient
+from utcp_http.http_call_template import HttpCallTemplate
async def main():
- # Create a UTCP client
- client = await UtcpClient.create()
-
- # Define the manual provider (points to the discovery endpoint)
- manual_provider = HttpProvider(
- name="weather_service",
- provider_type="http",
- http_method="GET",
- url="http://localhost:8000/utcp"
- )
-
- # Register tools from the manual provider
- tools = await client.register_tool_provider(manual_provider)
- print(f"Registered {len(tools)} tools from {manual_provider.name}")
+ # Create a UTCP client with configuration
+ client = await UtcpClient.create(config={
+ "manual_call_templates": [
+ {
+ "name": "weather_service",
+ "call_template_type": "http",
+ "http_method": "GET",
+ "url": "http://localhost:8000/utcp"
+ }
+ ]
+ })
- # Call a tool by its namespaced name: {provider_name}.{tool_name}
+ # Tools are automatically registered from the manual call templates
+ # Call a tool by its namespaced name: {manual_name}.{tool_name}
result = await client.call_tool(
"weather_service.get_weather",
- arguments={"location": "San Francisco"}
+ tool_args={"location": "San Francisco"}
)
print(f"Weather: {result['temperature']}°C, {result['conditions']}")
diff --git a/docs/providers/cli.md b/docs/providers/cli.md
deleted file mode 100644
index ee79949..0000000
--- a/docs/providers/cli.md
+++ /dev/null
@@ -1,186 +0,0 @@
----
-id: cli
-title: CLI Provider
-sidebar_position: 4
----
-
-# CLI Provider (WIP)
-
-The CLI provider enables UTCP to interact with local command-line tools and utilities, allowing AI agents to leverage existing command-line interfaces without requiring API wrappers.
-
-## Configuration
-
-CLI providers are configured using the following JSON structure:
-
-```json
-{
- "name": "my_cli_tool",
- "provider_type": "cli",
- "command_name": "my-command",
- "working_dir": "/path/to/data",
- "env_vars": {
- "MY_VAR": "some_value"
- }
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|--------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"cli"` |
-| `command_name` | Yes | Name of the CLI command to execute. |
-| `working_dir` | No | The working directory from which to run the command. |
-| `env_vars` | No | A dictionary of environment variables to set for the command's execution context. |
-
-## Tool Discovery
-
-CLI tools can expose their UTCP tool definitions in one of two ways:
-
-1. **Discovery Flag**: The CLI tool accepts a special flag (e.g., `-utcp` or `--utcp-info`) that outputs the tool definitions in JSON format
-
-```bash
-$ my-command --utcp-info
-{
- "version": "1.0",
- "tools": [
- {
- "name": "convert",
- "description": "Convert between file formats",
- "inputs": { ... },
- "outputs": { ... },
- "provider": { ... }
- }
- ]
-}
-```
-
-2. **Static Definition**: The tool definitions are provided in a separate JSON file or in the provider configuration
-
-```json
-{
- "name": "my_cli_tool",
- "provider_type": "cli",
- "command_name": "my-command",
- "tools": [
- {
- "name": "convert",
- "description": "Convert between file formats",
- "inputs": { ... },
- "outputs": { ... }
- }
- ]
-}
-```
-
-## Tool Calling
-
-When a tool associated with a CLI provider is called, the UTCP client will:
-
-1. Construct a command line from the provider configuration and tool parameters
-2. Execute the command as a subprocess
-3. Capture and parse the command's output according to the tool's output schema
-
-### Parameter Passing
-
-CLI tools can receive parameters in several ways, specified by the `param_style` field:
-
-```json
-{
- "name": "my_cli_tool",
- "provider_type": "cli",
- "command_name": "my-command",
- "param_style": "named"
-}
-```
-
-Available parameter styles:
-
-| Style | Description | Example |
-|-------|-------------|---------|
-| `named` | Parameters as named options (`--name value`) | `my-command --input file.txt --format json` |
-| `positional` | Parameters as positional arguments | `my-command file.txt json` |
-| `json` | Parameters as a JSON string in a single argument | `my-command '{"input": "file.txt", "format": "json"}'` |
-| `json_stdin` | Parameters as JSON sent to the command's standard input | `echo '{"input": "file.txt"}' \| my-command` |
-
-## Output Parsing
-
-CLI tools can output results in various formats:
-
-```json
-{
- "name": "my_cli_tool",
- "provider_type": "cli",
- "command_name": "my-command",
- "output_format": "json"
-}
-```
-
-Available output formats:
-
-| Format | Description |
-|--------|-------------|
-| `json` | Command outputs JSON that can be directly parsed |
-| `text` | Command outputs plain text that needs custom parsing |
-| `csv` | Command outputs CSV data that will be parsed into an array |
-| `xml` | Command outputs XML that will be parsed into a JSON structure |
-
-## Examples
-
-### Simple CLI Tool
-
-```json
-{
- "name": "file_converter",
- "provider_type": "cli",
- "command_name": "convert",
- "param_style": "named"
-}
-```
-
-When calling a tool with this provider:
-```bash
-convert --input document.docx --output document.pdf --format pdf
-```
-
-### Advanced CLI Tool
-
-```json
-{
- "name": "data_processor",
- "provider_type": "cli",
- "command_name": "process-data",
- "param_style": "json_stdin",
- "output_format": "json",
- "working_dir": "/path/to/data",
- "env": {
- "PYTHONPATH": "/custom/python/path",
- "DEBUG": "1"
- }
-}
-```
-
-## Security Considerations
-
-:::warning
-
-CLI providers execute commands on the local system, which presents significant security risks if not properly managed.
-
-To mitigate these risks:
-
-1. **Input Validation**: Strictly validate all parameters against the tool's input schema
-2. **Path Traversal Protection**: Sanitize file paths to prevent directory traversal attacks
-3. **Command Injection Prevention**: Escape or validate arguments to prevent injection attacks
-4. **Permission Limitations**: Run commands with the minimum necessary permissions
-5. **Resource Limits**: Implement timeouts and resource constraints
-
-## Best Practices
-
-1. **Structured Output**: Prefer CLI tools that output structured data (JSON, CSV, etc.)
-2. **Error Handling**: Capture and parse stderr for error messages
-3. **Logging**: Log command executions for audit and debugging purposes
-4. **Async Execution**: For long-running commands, implement asynchronous execution
-5. **Result Caching**: Cache results when appropriate to reduce command executions
-
-The CLI provider bridges the gap between modern AI agents and traditional command-line utilities, enabling powerful integrations without requiring API development.
diff --git a/docs/providers/graphql.md b/docs/providers/graphql.md
deleted file mode 100644
index ee8d98c..0000000
--- a/docs/providers/graphql.md
+++ /dev/null
@@ -1,190 +0,0 @@
----
-id: graphql
-title: GraphQL Provider
-sidebar_position: 7
----
-
-# GraphQL Provider (WIP)
-
-The GraphQL provider enables UTCP to interact with GraphQL APIs, allowing for precise data fetching and operations with a flexible query language.
-
-## Configuration
-
-GraphQL providers are configured using the following JSON structure:
-
-```json
-{
- "name": "graphql_api",
- "provider_type": "graphql",
- "url": "https://api.example.com/graphql",
- "operation_type": "query",
- "operation_name": "GetUser",
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "Authorization"
- },
- "headers": {
- "User-Agent": "UTCP Client"
- },
- "header_fields": ["client_version"]
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"graphql"` |
-| `url` | Yes | Full URL to the GraphQL endpoint |
-| `operation_type` | No | Type of GraphQL operation: `"query"`, `"mutation"`, or `"subscription"` (default: `"query"`) |
-| `operation_name` | No | Name of the GraphQL operation (optional) |
-| `auth` | No | Authentication configuration (if required) |
-| `headers` | No | Additional HTTP headers to include in the request |
-| `header_fields` | No | List of input fields to be sent as request headers for the initial connection |
-
-## Tool Discovery
-
-For GraphQL providers, the tool discovery endpoint should be accessible at `/utcp` on the same domain as the API. For example:
-
-```
-https://api.example.com/utcp
-```
-
-Alternatively, tools can be discovered through introspection of the GraphQL schema.
-
-## Authentication
-
-GraphQL providers support the same authentication methods as HTTP providers:
-
-- API Key (in headers)
-- Basic Authentication
-- OAuth2
-
-## Making Tool Calls
-
-When a tool associated with a GraphQL provider is called, the UTCP client will:
-
-1. Construct a GraphQL document based on the operation type and input parameters
-2. Send a request to the GraphQL endpoint with the appropriate headers and authentication
-3. Process the response according to the tool's output schema
-
-## Examples
-
-### User Query
-
-```json
-{
- "name": "user_api",
- "provider_type": "graphql",
- "url": "https://api.example.com/graphql",
- "operation_type": "query"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "get_user",
- "description": "Get user information by ID",
- "inputs": {
- "type": "object",
- "properties": {
- "id": {
- "type": "string",
- "description": "User ID"
- }
- },
- "required": ["id"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "name": {
- "type": "string",
- "description": "User's name"
- },
- "email": {
- "type": "string",
- "description": "User's email"
- },
- "role": {
- "type": "string",
- "description": "User's role"
- }
- }
- }
-}
-```
-
-Example GraphQL query:
-```graphql
-query GetUser($id: ID!) {
- user(id: $id) {
- name
- email
- role
- }
-}
-```
-
-### Product Creation
-
-```json
-{
- "name": "product_api",
- "provider_type": "graphql",
- "url": "https://api.example.com/graphql",
- "operation_type": "mutation"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "create_product",
- "description": "Create a new product",
- "inputs": {
- "type": "object",
- "properties": {
- "name": {
- "type": "string",
- "description": "Product name"
- },
- "price": {
- "type": "number",
- "description": "Product price"
- },
- "category": {
- "type": "string",
- "description": "Product category"
- }
- },
- "required": ["name", "price"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "id": {
- "type": "string",
- "description": "New product ID"
- },
- "success": {
- "type": "boolean",
- "description": "Whether the operation was successful"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Precise Queries**: GraphQL allows for precise data selection, reducing overhead
-2. **Error Handling**: Process GraphQL-specific errors in the response
-3. **Batching**: Consider batching multiple operations in a single request when possible
-4. **Fragments**: Use fragments for reusable components in GraphQL operations
-5. **Rate Limiting**: Be aware of rate limits and implement appropriate throttling
-
-GraphQL providers offer flexible data fetching capabilities, making them ideal for complex data requirements with minimal network overhead.
diff --git a/docs/providers/grpc.md b/docs/providers/grpc.md
deleted file mode 100644
index 12eaf08..0000000
--- a/docs/providers/grpc.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-id: grpc
-title: gRPC Provider
-sidebar_position: 6
----
-
-# gRPC Provider (WIP)
-
-:::warning
-
-> This provider type is currently a Work In Progress (WIP) and may be subject to changes.
-:::
-The gRPC provider enables UTCP to interact with gRPC services, allowing for efficient, schema-driven communication with high performance and low latency.
-
-## Configuration
-
-gRPC providers are configured using the following JSON structure:
-
-```json
-{
- "name": "grpc_service",
- "provider_type": "grpc",
- "host": "api.example.com",
- "port": 50051,
- "service_name": "Calculator",
- "method_name": "Add",
- "use_ssl": true,
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "x-api-key"
- }
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"grpc"` |
-| `host` | Yes | Hostname or IP address of the gRPC server |
-| `port` | Yes | Port number of the gRPC server |
-| `service_name` | Yes | Name of the gRPC service to call |
-| `method_name` | Yes | Name of the method to call on the service |
-| `use_ssl` | No | Whether to use SSL/TLS for the connection (default: `false`) |
-| `auth` | No | Authentication configuration (if required) |
-
-## Tool Discovery
-
-Since gRPC doesn't natively support dynamic discovery, UTCP tools can be discovered in one of these ways:
-
-1. **Reflection**: If the gRPC server supports reflection, the UTCP client can query available services and methods
-2. **Static Definition**: Tool definitions are provided in a separate JSON file or in the provider configuration
-3. **Companion HTTP Endpoint**: A companion HTTP endpoint (typically `/utcp`) that returns the tool definitions
-
-## Authentication
-
-gRPC providers support several authentication methods:
-
-- API Key (via metadata)
-- OAuth2 (via token)
-- TLS Client Certificates
-
-## Making Tool Calls
-
-When a tool associated with a gRPC provider is called, the UTCP client will:
-
-1. Establish a connection to the gRPC server with the specified host and port
-2. Include any authentication metadata
-3. Call the specified service method with the input parameters
-4. Return the response according to the tool's output schema
-
-## Examples
-
-### Calculator Service
-
-```json
-{
- "name": "calculator",
- "provider_type": "grpc",
- "host": "calc.example.com",
- "port": 50051,
- "service_name": "Calculator",
- "method_name": "Add"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "add",
- "description": "Add two numbers",
- "inputs": {
- "type": "object",
- "properties": {
- "a": {
- "type": "number",
- "description": "First number"
- },
- "b": {
- "type": "number",
- "description": "Second number"
- }
- },
- "required": ["a", "b"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "result": {
- "type": "number",
- "description": "Sum of the two numbers"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Proto Definitions**: Make sure the client has access to the proto definitions for the gRPC service
-2. **Connection Pooling**: For high-volume scenarios, implement connection pooling
-3. **Timeouts**: Set appropriate deadlines for gRPC calls
-4. **Error Handling**: Handle gRPC-specific error codes appropriately
-5. **Streaming**: Consider using gRPC streaming for large data transfers or real-time updates
-
-gRPC providers offer significant performance benefits over HTTP-based APIs, making them ideal for high-throughput or latency-sensitive applications.
diff --git a/docs/providers/http-stream.md b/docs/providers/http-stream.md
deleted file mode 100644
index 1d2244b..0000000
--- a/docs/providers/http-stream.md
+++ /dev/null
@@ -1,137 +0,0 @@
----
-id: http-stream
-title: HTTP Stream Provider
-sidebar_position: 3
----
-
-# HTTP Stream Provider (WIP)
-
-The HTTP Stream provider enables streaming data transfers over HTTP using chunked transfer encoding, making it suitable for scenarios where continuous data needs to be sent over standard HTTP infrastructure.
-
-## Configuration
-
-HTTP Stream providers are configured using the following JSON structure:
-
-```json
-{
- "name": "streaming_service",
- "provider_type": "http_stream",
- "url": "https://api.example.com/stream",
- "http_method": "POST",
- "content_type": "application/octet-stream",
- "chunk_size": 4096,
- "timeout": 60000,
- "headers": {
- "User-Agent": "UTCP Client"
- },
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "X-API-Key"
- },
- "body_field": "prompt",
- "header_fields": ["stream_format", "model"]
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"http_stream"` |
-| `url` | Yes | Full URL to the streaming endpoint |
-| `http_method` | No | HTTP method to use (default: `"GET"`). Can be `GET` or `POST`. |
-| `content_type` | No | Content type header (default: `"application/octet-stream"`) |
-| `chunk_size` | No | Size of chunks in bytes (default: `4096`) |
-| `timeout` | No | Timeout in milliseconds (default: `60000`) |
-| `headers` | No | Additional HTTP headers to include in the request |
-| `auth` | No | Authentication configuration (if required) |
-| `body_field` | No | The name of the single input field to be sent as the request body |
-| `header_fields` | No | List of input fields to be sent as request headers |
-
-## Tool Discovery
-
-For HTTP Stream providers, the tool discovery endpoint should be accessible at `/utcp` on the same domain as the API. For example:
-
-```
-https://api.example.com/utcp
-```
-
-## Authentication
-
-HTTP Stream providers support the same authentication methods as standard HTTP providers:
-
-- API Key (in headers)
-- Basic Authentication
-- OAuth2
-
-## Making Tool Calls
-
-When a tool associated with an HTTP Stream provider is called, the UTCP client will:
-
-1. Establish an HTTP connection to the specified URL with the appropriate method
-2. Set the appropriate headers and include input parameters as query parameters or in the request body
-3. Process the chunked response data according to the tool's output schema
-4. Continue receiving chunks until the connection is closed or the timeout is reached
-
-## Examples
-
-### Text Generation Stream
-
-```json
-{
- "name": "text_generator",
- "provider_type": "http_stream",
- "url": "https://ai.example.com/generate/stream",
- "http_method": "POST",
- "content_type": "application/json",
- "body_field": "prompt"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "generate_text",
- "description": "Generate text from a prompt with streaming response",
- "inputs": {
- "type": "object",
- "properties": {
- "prompt": {
- "type": "string",
- "description": "The prompt to generate text from"
- },
- "max_tokens": {
- "type": "integer",
- "description": "Maximum tokens to generate",
- "default": 100
- }
- },
- "required": ["prompt"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "text": {
- "type": "string",
- "description": "Generated text chunk"
- },
- "finished": {
- "type": "boolean",
- "description": "Whether this is the final chunk"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Error Handling**: Implement robust error handling for connection issues and malformed chunks
-2. **Backpressure**: Consider implementing backpressure mechanisms for high-volume streams
-3. **Reconnection**: Implement reconnection logic with backoff for unreliable networks
-4. **Timeouts**: Set appropriate timeouts based on expected response times
-5. **Partial Processing**: Design tools to handle partial data effectively
-
-HTTP Stream providers bridge the gap between standard HTTP APIs and streaming use cases, making them ideal for situations where WebSockets or SSE might be blocked by firewalls or proxies.
diff --git a/docs/providers/http.md b/docs/providers/http.md
deleted file mode 100644
index bdfe70d..0000000
--- a/docs/providers/http.md
+++ /dev/null
@@ -1,201 +0,0 @@
----
-id: http
-title: HTTP Provider
-sidebar_position: 1
----
-
-# HTTP Provider
-
-The HTTP provider enables UTCP to interact with standard RESTful HTTP/HTTPS APIs, which are the most common type of web service.
-
-## Configuration
-
-HTTP providers are configured using the following JSON structure:
-
-```json
-{
- "name": "my_rest_api",
- "provider_type": "http",
- "url": "https://api.example.com/endpoint",
- "http_method": "POST",
- "content_type": "application/json",
- "auth": {
- "auth_type": "api_key",
- "api_key": "YOUR_API_KEY",
- "var_name": "X-API-Key"
- },
- "headers": {
- "X-Custom-Header": "custom_value"
- },
- "body_field": "request_body",
- "header_fields": ["user_id"]
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"http"` |
-| `url` | Yes | Full URL to the API endpoint |
-| `http_method` | No | HTTP method to use (default: `"GET"`). Can be `GET`, `POST`, `PUT`, `DELETE`, or `PATCH`. |
-| `content_type` | No | Content type header (default: `"application/json"`) |
-| `auth` | No | Authentication configuration (if required) |
-| `headers` | No | A dictionary of static headers to include in every request. |
-| `body_field`| No | The name of a single input field to be sent as the raw request body. If not provided, all inputs are sent as a JSON object. |
-| `header_fields`| No | A list of input fields to be sent as request headers instead of in the body or query string. |
-
-## Tool Discovery
-
-For HTTP providers, the tool discovery endpoint should be accessible at `/utcp` on the same domain as the API. For example:
-
-```
-https://api.example.com/utcp
-```
-
-The discovery endpoint should return a `UTCPManual` object as described in the [For Tool Providers](../for-tool-providers) section.
-
-## Authentication Options
-
-HTTP providers support several authentication methods:
-
-### API Key Authentication
-
-```json
-{
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "X-API-Key"
- }
-}
-```
-
-The API key will be sent as a header with the name specified in `var_name`.
-
-### Basic Authentication
-
-```json
-{
- "auth": {
- "auth_type": "basic",
- "username": "user",
- "password": "pass"
- }
-}
-```
-
-The username and password will be encoded and sent in the `Authorization` header.
-
-### OAuth2 Authentication
-
-```json
-{
- "auth": {
- "auth_type": "oauth2",
- "client_id": "$YOUR_CLIENT_ID",
- "client_secret": "$YOUR_CLIENT_SECRET",
- "token_url": "https://auth.example.com/token"
- }
-}
-```
-
-The client will handle obtaining and refreshing OAuth2 tokens.
-
-## Making Tool Calls
-
-When a tool associated with an HTTP provider is called, the UTCP client will:
-
-1. Construct an HTTP request to the specified URL
-2. Use the specified HTTP method (or default to POST)
-3. Set the content type header (or default to application/json)
-4. Add authentication headers if specified
-5. Send the tool parameters in the request body (for POST/PUT) or as query parameters (for GET)
-6. Parse the response according to the tool's output schema
-
-## Examples
-
-### Simple GET Request
-
-```json
-{
- "name": "weather_api",
- "provider_type": "http",
- "url": "https://api.weather.com/forecast",
- "http_method": "GET"
-}
-```
-
-When calling a tool with this provider, parameters would be sent as query parameters:
-```
-GET https://api.weather.com/forecast?location=San%20Francisco&days=5
-```
-
-### POST Request with API Key
-
-```json
-{
- "name": "translation_api",
- "provider_type": "http",
- "url": "https://api.translation.com/translate",
- "http_method": "POST",
- "content_type": "application/json",
- "auth": {
- "auth_type": "api_key",
- "api_key": "abcd1234",
- "var_name": "X-API-Key"
- }
-}
-```
-
-When calling a tool with this provider, parameters would be sent in the request body:
-```
-POST https://api.translation.com/translate
-Header: X-API-Key: abcd1234
-Body: {"text": "Hello world", "target_language": "es"}
-```
-
-### Advanced Usage: `body_field` and `header_fields`
-
-You can use `body_field` to send a single parameter as the raw request body, and `header_fields` to map tool inputs to HTTP headers.
-
-```json
-{
- "name": "file_upload_api",
- "provider_type": "http",
- "url": "https://api.example.com/upload",
- "http_method": "POST",
- "content_type": "text/plain",
- "body_field": "file_content",
- "header_fields": ["X-File-Name", "X-User-ID"]
-}
-```
-
-If a tool with this provider is called with inputs `{"file_content": "...", "X-File-Name": "report.txt", "X-User-ID": "user123"}` the request would be:
-
-```
-POST https://api.example.com/upload
-Header: X-File-Name: report.txt
-Header: X-User-ID: user123
-Body: ... (raw content of file_content)
-```
-
-## Best Practices
-
-1. **Use HTTPS**: Always use HTTPS URLs for security
-2. **Handle Rate Limits**: Implement rate limiting and backoff strategies
-3. **Validate Responses**: Check HTTP status codes and implement appropriate error handling
-4. **Cache Results**: For GET requests, consider caching responses when appropriate
-5. **Parameter Validation**: Validate parameters against the tool's input schema before sending
-
-## Common Issues
-
-| Issue | Solution |
-|-------|----------|
-| Connection timeouts | Implement retry logic with exponential backoff |
-| Rate limiting | Honor API rate limits and implement backoff strategies |
-| Authentication failures | Verify credentials and check for token expiration |
-| CORS issues | Ensure the API supports CORS if called from a browser |
-
-In the next section, we'll explore the [SSE Provider](sse) for server-sent events, which enables streaming responses from HTTP endpoints.
diff --git a/docs/providers/mcp.md b/docs/providers/mcp.md
deleted file mode 100644
index 61f51f1..0000000
--- a/docs/providers/mcp.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-id: mcp
-title: MCP Provider
-sidebar_position: 11
----
-
-# MCP Provider (WIP)
-
-The MCP (Model Context Protocol) provider enables UTCP to interoperate with services that implement the Model Context Protocol, allowing for compatibility with MCP ecosystems.
-
-## Configuration
-
-MCP providers are configured using the following JSON structure:
-
-```json
-{
- "name": "mcp_service",
- "provider_type": "mcp",
- "config": {
- "mcpServers": {
- "stdio_server": {
- "transport": "stdio",
- "command": "mcp-server",
- "args": ["--port", "8080"],
- "env": {
- "MCP_API_KEY": "$YOUR_API_KEY"
- }
- },
- "http_server": {
- "transport": "http",
- "url": "https://mcp.example.com/stream"
- }
- }
- },
- "auth": {
- "auth_type": "oauth2",
- "client_id": "$YOUR_CLIENT_ID",
- "client_secret": "$YOUR_CLIENT_SECRET",
- "token_url": "https://auth.example.com/token"
- }
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"mcp"` |
-| `config` | Yes | MCP configuration object containing server definitions |
-| `config.mcpServers` | Yes | Dictionary of MCP server configurations |
-| `auth` | No | Authentication configuration. Must be of type `OAuth2Auth`. |
-
-### MCP Server Configuration
-
-Each MCP server entry in the `mcpServers` dictionary defines a connection to an MCP server and must specify its `transport` type, which can be `stdio` or `http`.
-
-#### Stdio Transport
-
-For servers connected via standard input/output.
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `transport` | Yes | Must be `"stdio"`. |
-| `command` | Yes | The command to launch the MCP server. |
-| `args` | No | Command line arguments for the MCP server. |
-| `env` | No | Environment variables for the MCP server. |
-
-#### HTTP Transport
-
-For servers connected via streamable HTTP.
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `transport` | Yes | Must be `"http"`. |
-| `url` | Yes | The URL of the MCP server's streaming endpoint. |
-
-## Tool Discovery
-
-For MCP providers, UTCP tools are discovered through the MCP server's own discovery mechanism and then mapped to UTCP tools.
-
-## Interoperability
-
-The MCP provider serves as a bridge between UTCP and MCP ecosystems, allowing:
-
-1. UTCP clients to access tools from MCP servers
-2. MCP clients to access tools from UTCP providers (through an MCP adapter)
-
-## Making Tool Calls
-
-When a tool associated with an MCP provider is called, the UTCP client will:
-
-1. Translate the UTCP tool call into an MCP tool call format
-2. Send the request to the appropriate MCP server
-3. Wait for the MCP server's response
-4. Translate the MCP response back into the UTCP format
-5. Return the result according to the tool's output schema
-
-## Examples
-
-### AI Model Access
-
-```json
-{
- "name": "ai_models",
- "provider_type": "mcp",
- "config": {
- "mcpServers": {
- "llm": {
- "command": "mcp-llm-server",
- "args": ["--models", "all"],
- "env": {
- "MODEL_API_KEY": "$YOUR_MODEL_API_KEY"
- }
- }
- }
- }
-}
-```
-
-Tool definition:
-```json
-{
- "name": "generate_text",
- "description": "Generate text from a prompt using an AI model",
- "inputs": {
- "type": "object",
- "properties": {
- "prompt": {
- "type": "string",
- "description": "The prompt to generate text from"
- },
- "model": {
- "type": "string",
- "description": "Model to use",
- "default": "default-model"
- },
- "max_tokens": {
- "type": "integer",
- "description": "Maximum tokens to generate",
- "default": 100
- }
- },
- "required": ["prompt"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "text": {
- "type": "string",
- "description": "Generated text"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Version Compatibility**: Ensure compatibility between UTCP and MCP versions
-2. **Configuration Management**: Properly manage MCP server configurations
-3. **Error Translation**: Map MCP-specific errors to appropriate UTCP errors
-4. **Security Considerations**: Handle authentication and credentials securely
-5. **Resource Management**: Properly manage MCP server lifecycle if launched by the UTCP client
-
-The MCP provider enables integration with existing MCP ecosystems, providing a path for migration and interoperability between the two protocols.
diff --git a/docs/providers/providers.md b/docs/providers/providers.md
deleted file mode 100644
index 5582bc8..0000000
--- a/docs/providers/providers.md
+++ /dev/null
@@ -1,136 +0,0 @@
----
-id: providers
-title: Provider Types
-sidebar_position: 4
----
-
-# Provider Types
-
-Providers are at the heart of UTCP's flexibility. They define the specific communication protocol and configuration needed to interact with a tool. This design allows UTCP to support a wide range of existing and future communication methods.
-
-## Overview
-
-Each tool in UTCP is associated with a provider that specifies:
-- The communication protocol to use (HTTP, WebSocket, CLI, etc.)
-- The connection details (URL, host, port, command name, etc.)
-- Authentication requirements (if any)
-
-This provider-based approach offers several benefits:
-- Eliminates the need for middleman servers
-- Allows direct use of a tool's native interface
-- Enables seamless integration with tools across different protocols
-
-## Core Provider Attributes
-
-All providers share some common attributes:
-
-```json
-{
- "name": "provider_name",
- "provider_type": "provider_type",
- ... (protocol-specific attributes)
-}
-```
-
-| Field | Description |
-|-------|-------------|
-| `name` | A unique identifier for the provider |
-| `provider_type` | The protocol type (e.g., "http", "websocket", "cli") |
-
-## Supported Provider Types
-
-UTCP supports the following provider types:
-
-| Provider Type | Description |
-|---------------|-------------|
-| [`http`](providers/http) | RESTful HTTP/HTTPS APIs |
-| [`sse`](providers/sse) | Server-Sent Events |
-| [`http_stream`](providers/http-stream) | HTTP Chunked Transfer Encoding |
-| [`cli`](providers/cli) | Command Line Interface tools |
-| [`websocket (WIP)`](providers/websocket) | WebSocket bidirectional connection |
-| [`grpc (WIP)`](providers/grpc) | gRPC (Google Remote Procedure Call) |
-| [`graphql`](providers/graphql) | GraphQL query language |
-| [`tcp (WIP)`](providers/tcp) | Raw TCP socket |
-| [`udp (WIP)`](providers/udp) | User Datagram Protocol |
-| [`webrtc (WIP)`](providers/webrtc) | Web Real-Time Communication |
-| [`mcp`](providers/mcp) | Model Context Protocol (for interoperability) |
-| [`text`](providers/text) | Local file-based tool definitions |
-
-Each provider type has its own specific configuration options, which are detailed in the individual provider documentation pages.
-
-## Variable Substitution
-
-UTCP supports variable substitution in provider configurations. Any value prefixed with `$` or enclosed in `${...}` will be treated as a variable to be resolved at runtime.
-
-```json
-{
- "url": "https://${DOMAIN}/api/v1",
- "auth": {
- "auth_type": "api_key",
- "api_key": "$API_KEY"
- }
-}
-```
-
-Variable resolution follows this order:
-1. Client configuration variables
-2. Environment variables
-
-If a variable cannot be resolved, the client will raise an error indicating which variable is missing.
-
-This approach enables:
-- Secure handling of sensitive credentials
-- Environment-specific configurations
-- Separation of provider definition from runtime secrets
-
-## Authentication
-
-Many providers require authentication to access their tools. UTCP supports several authentication methods:
-
-### API Key Authentication
-
-```json
-{
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "X-API-Key"
- }
-}
-```
-
-### Basic Authentication
-
-```json
-{
- "auth": {
- "auth_type": "basic",
- "username": "user",
- "password": "pass"
- }
-}
-```
-
-### OAuth2 Authentication
-
-```json
-{
- "auth": {
- "auth_type": "oauth2",
- "client_id": "$YOUR_CLIENT_ID",
- "client_secret": "$YOUR_CLIENT_SECRET",
- "token_url": "https://auth.example.com/token"
- }
-}
-```
-
-## Provider Selection Guidelines
-
-When choosing a provider type for your tool:
-
-1. **Use the native protocol**: Select the provider type that matches your tool's native interface
-2. **Consider performance**: Some protocols (like HTTP) have more overhead than others (like gRPC)
-3. **Think about streaming**: For tools that generate data incrementally, use streaming protocols like SSE, WebSockets, or HTTP Stream
-4. **Security requirements**: Consider authentication and encryption needs
-
-In the following sections, we'll explore each provider type in detail, with configuration examples and best practices.
diff --git a/docs/providers/sse.md b/docs/providers/sse.md
deleted file mode 100644
index 83f29cb..0000000
--- a/docs/providers/sse.md
+++ /dev/null
@@ -1,199 +0,0 @@
----
-id: sse
-title: SSE Provider
-sidebar_position: 2
----
-
-# Server-Sent Events (SSE) Provider (WIP)
-
-The SSE provider enables one-way streaming communication from servers to clients, making it ideal for real-time updates, notifications, and data feeds that don't require bidirectional communication.
-
-## Configuration
-
-SSE providers are configured using the following JSON structure:
-
-```json
-{
- "name": "live_updates_service",
- "provider_type": "sse",
- "url": "https://api.example.com/events",
- "event_type": "message",
- "reconnect": true,
- "retry_timeout": 30000,
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "X-API-Key"
- },
- "headers": {
- "User-Agent": "UTCP Client"
- },
- "body_field": "payload",
- "header_fields": ["api_version", "client_id"]
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|--------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"sse"` |
-| `url` | Yes | Full URL to the SSE endpoint |
-| `event_type` | No | The event type to listen for (default: `null`, which listens for all events) |
-| `reconnect` | No | Whether to automatically reconnect if the connection is lost (default: `true`) |
-| `retry_timeout` | No | Retry timeout in milliseconds if disconnected (default: `30000`) |
-| `auth` | No | Authentication configuration (if required) |
-| `headers` | No | Additional HTTP headers to include in the request |
-| `body_field` | No | The name of the single input field to be sent as the request body |
-| `header_fields` | No | List of input fields to be sent as request headers for the initial connection |
-
-## Tool Discovery
-
-For SSE providers, the tool discovery endpoint should be accessible at `/utcp` on the same domain as the API. For example:
-
-```
-https://api.example.com/utcp
-```
-
-Since SSE is primarily for receiving streaming data, tools that use SSE providers typically have simple inputs (to establish the connection) and structured streaming outputs.
-
-## Message Format
-
-SSE follows a text-based protocol where each message consists of one or more lines of text:
-
-```
-event: event_type
-id: message_id
-data: {"key": "value"}
-
-```
-
-In UTCP, the `data` field is expected to contain JSON that matches the tool's output schema.
-
-## Authentication
-
-SSE providers support the same authentication methods as HTTP providers:
-
-- API Key (in headers)
-- Basic Authentication
-- OAuth2
-
-Since SSE connections are essentially long-lived HTTP connections, authentication is typically handled during the initial connection request.
-
-## Making Tool Calls
-
-When a tool associated with an SSE provider is called, the UTCP client will:
-
-1. Establish an SSE connection to the specified URL with any input parameters as query parameters
-2. Listen for events of the specified type
-3. Parse each event's data according to the tool's output schema
-4. Continue receiving events until the connection is closed or the tool call is terminated
-
-## Reconnection Strategy
-
-SSE includes built-in reconnection support through the `Last-Event-ID` header. UTCP clients should:
-
-1. Store the last received event ID
-2. If the connection drops, reconnect with the `Last-Event-ID` header set
-3. Implement exponential backoff for reconnection attempts
-
-## Examples
-
-### Real-time Market Updates
-
-```json
-{
- "name": "market_updates",
- "provider_type": "sse",
- "url": "https://markets.example.com/stream",
- "event_type": "price_update"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "watch_stock",
- "description": "Get real-time price updates for a stock",
- "inputs": {
- "type": "object",
- "properties": {
- "symbol": {
- "type": "string",
- "description": "Stock symbol (e.g., AAPL)"
- }
- },
- "required": ["symbol"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "symbol": {
- "type": "string",
- "description": "Stock symbol"
- },
- "price": {
- "type": "number",
- "description": "Current price"
- },
- "change": {
- "type": "number",
- "description": "Price change"
- },
- "timestamp": {
- "type": "string",
- "description": "Update time"
- }
- }
- }
-}
-```
-
-Connection URL with parameters:
-```
-https://markets.example.com/stream?symbol=AAPL
-```
-
-### Notification System
-
-```json
-{
- "name": "notification_service",
- "provider_type": "sse",
- "url": "https://notify.example.com/events",
- "event_type": "notification",
- "auth": {
- "auth_type": "api_key",
- "api_key": "YOUR_API_KEY",
- "var_name": "X-API-Key"
- }
-}
-```
-
-## Handling Multiple Tools
-
-A single SSE connection can support multiple tools by:
-
-1. Using different event types for different tools
-2. Including a tool identifier in the event data
-3. Using filtering parameters in the connection URL
-
-## Best Practices
-
-1. **Connection Management**: Limit the number of concurrent SSE connections
-2. **Reconnection Logic**: Implement robust reconnection with backoff
-3. **Data Processing**: Handle events asynchronously to avoid blocking
-4. **Error Handling**: Monitor for connection issues and malformed data
-5. **Resource Cleanup**: Close SSE connections when they're no longer needed
-
-## Common Issues
-
-| Issue | Solution |
-|-------|----------|
-| Connection timeouts | Implement heartbeat messages or separate ping endpoint |
-| Proxy/firewall issues | Ensure infrastructure supports long-lived HTTP connections |
-| Event ordering | Use event IDs to track and potentially reorder messages |
-| Duplicate events | Track processed event IDs to avoid duplicates after reconnection |
-
-SSE providers are ideal for scenarios where clients need to receive real-time updates without the complexity of bidirectional protocols like WebSockets.
diff --git a/docs/providers/tcp.md b/docs/providers/tcp.md
deleted file mode 100644
index c27d4a7..0000000
--- a/docs/providers/tcp.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-id: tcp
-title: TCP Provider
-sidebar_position: 8
----
-
-# TCP Provider (WIP)
-
-:::warning
-
-> This provider type is currently a Work In Progress (WIP) and may be subject to changes.
-:::
-The TCP provider enables UTCP to interact directly with services over raw TCP sockets, allowing for low-level network communication with minimal protocol overhead.
-
-## Configuration
-
-TCP providers are configured using the following JSON structure:
-
-```json
-{
- "name": "tcp_service",
- "provider_type": "tcp",
- "host": "api.example.com",
- "port": 9000,
- "timeout": 30000
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"tcp"` |
-| `host` | Yes | Hostname or IP address of the TCP server |
-| `port` | Yes | Port number of the TCP server |
-| `timeout` | No | Connection and operation timeout in milliseconds (default: `30000`) |
-
-## Tool Discovery
-
-Since raw TCP doesn't support standardized discovery protocols, UTCP tools using TCP providers typically rely on:
-
-1. **Static Definition**: Tool definitions are provided in a separate JSON file or in the provider configuration
-2. **Companion HTTP Endpoint**: A companion HTTP endpoint (typically `/utcp`) that returns the tool definitions
-
-## Making Tool Calls
-
-When a tool associated with a TCP provider is called, the UTCP client will:
-
-1. Establish a TCP connection to the specified host and port
-2. Send the serialized input parameters according to the tool's protocol
-3. Read the response data from the socket
-4. Process the response according to the tool's output schema
-5. Close the connection (unless persistent connections are used)
-
-## Protocol Considerations
-
-Since TCP is a raw transport protocol, implementations need to define:
-
-1. **Message Framing**: How to determine message boundaries (length prefixes, delimiters, etc.)
-2. **Data Serialization**: Format for sending structured data (JSON, Protocol Buffers, custom binary, etc.)
-3. **Error Handling**: How errors are communicated in the protocol
-
-## Examples
-
-### Time Server
-
-```json
-{
- "name": "time_server",
- "provider_type": "tcp",
- "host": "time.example.com",
- "port": 13
-}
-```
-
-Tool definition:
-```json
-{
- "name": "get_time",
- "description": "Get current time from a time server",
- "inputs": {
- "type": "object",
- "properties": {
- "format": {
- "type": "string",
- "description": "Time format",
- "enum": ["short", "long"],
- "default": "short"
- }
- }
- },
- "outputs": {
- "type": "object",
- "properties": {
- "time": {
- "type": "string",
- "description": "Current time"
- },
- "timezone": {
- "type": "string",
- "description": "Timezone"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Connection Pooling**: For frequently used services, implement connection pooling
-2. **Reconnection Logic**: Implement robust reconnection with backoff for network failures
-3. **Timeouts**: Set appropriate timeouts for connection and operations
-4. **Message Framing**: Clearly define how message boundaries are determined
-5. **Data Validation**: Validate incoming and outgoing data against schemas
-
-TCP providers are ideal for high-performance, low-latency applications where protocol overhead needs to be minimized, or for interacting with legacy systems that use custom TCP protocols.
diff --git a/docs/providers/text.md b/docs/providers/text.md
deleted file mode 100644
index e4e010a..0000000
--- a/docs/providers/text.md
+++ /dev/null
@@ -1,152 +0,0 @@
----
-id: text
-title: Text Provider
-sidebar_position: 12
----
-
-# Text Provider (WIP)
-
-The Text provider enables UTCP to interact with tools defined in local text files, which is useful for file-based tools or for creating aggregated collections of tools from different providers.
-
-## Configuration
-
-Text providers are configured using the following JSON structure:
-
-```json
-{
- "name": "local_tools",
- "provider_type": "text",
- "file_path": "/path/to/tools.json"
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"text"` |
-| `file_path` | Yes | Path to the file containing the tool definitions |
-
-## Tool Discovery
-
-For Text providers, tool discovery is straightforward - the tools are defined directly in the text file specified by `file_path`. This file should contain a JSON array of tool definitions or a UTCPManual object.
-
-## Making Tool Calls
-
-The Text provider can be used in two main ways:
-
-1. **File-Based Tools**: The tool call is delegated to a process that writes results to a file which the provider then reads
-2. **Tool Aggregation**: The provider acts as a collection point for tools from different providers
-
-## Examples
-
-### File-Based Tools
-
-```json
-{
- "name": "local_file_tools",
- "provider_type": "text",
- "file_path": "/etc/utcp/local_tools.json"
-}
-```
-
-Example content of `local_tools.json`:
-```json
-{
- "version": "1.0",
- "tools": [
- {
- "name": "read_system_stats",
- "description": "Read system statistics",
- "inputs": {
- "type": "object",
- "properties": {
- "stat_type": {
- "type": "string",
- "enum": ["cpu", "memory", "disk"],
- "description": "Type of statistics to read"
- }
- },
- "required": ["stat_type"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "usage_percent": {
- "type": "number",
- "description": "Usage percentage"
- },
- "details": {
- "type": "object",
- "description": "Detailed statistics"
- }
- }
- },
- "provider": {
- "name": "system",
- "provider_type": "cli",
- "command_name": "system-stats"
- }
- }
- ]
-}
-```
-
-### Tool Aggregation
-
-```json
-{
- "name": "tool_collection",
- "provider_type": "text",
- "file_path": "/etc/utcp/aggregated_tools.json"
-}
-```
-
-Example content of `aggregated_tools.json`:
-```json
-{
- "version": "1.0",
- "tools": [
- {
- "name": "weather",
- "description": "Get weather information",
- "provider": {
- "name": "weather_api",
- "provider_type": "http",
- "url": "https://api.example.com/weather",
- "http_method": "GET"
- }
- },
- {
- "name": "translate",
- "description": "Translate text",
- "provider": {
- "name": "translation_api",
- "provider_type": "http",
- "url": "https://api.example.com/translate",
- "http_method": "POST"
- }
- },
- {
- "name": "notify",
- "description": "Send notifications",
- "provider": {
- "name": "notification_service",
- "provider_type": "websocket",
- "url": "wss://api.example.com/notifications"
- }
- }
- ]
-}
-```
-
-## Best Practices
-
-1. **File Permissions**: Ensure proper read permissions for the tool definition files
-2. **File Watching**: Consider implementing file watching to detect changes to tool definitions
-3. **Validation**: Validate tool definitions against the UTCP schema before using
-4. **Path Resolution**: Implement proper path resolution, supporting both absolute and relative paths
-5. **Error Handling**: Handle file access errors gracefully
-
-The Text provider is particularly useful for development, testing, and for situations where tools need to be defined locally without requiring a server component.
diff --git a/docs/providers/udp.md b/docs/providers/udp.md
deleted file mode 100644
index 2b54547..0000000
--- a/docs/providers/udp.md
+++ /dev/null
@@ -1,126 +0,0 @@
----
-id: udp
-title: UDP Provider
-sidebar_position: 9
----
-
-# UDP Provider (WIP)
-
-:::warning
-
-> This provider type is currently a Work In Progress (WIP) and may be subject to changes.
-:::
-The UDP provider enables UTCP to interact with services over User Datagram Protocol, offering low-latency communication with minimal overhead for applications where occasional packet loss is acceptable.
-
-## Configuration
-
-UDP providers are configured using the following JSON structure:
-
-```json
-{
- "name": "udp_service",
- "provider_type": "udp",
- "host": "api.example.com",
- "port": 9200,
- "timeout": 30000
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"udp"` |
-| `host` | Yes | Hostname or IP address of the UDP server |
-| `port` | Yes | Port number of the UDP server |
-| `timeout` | No | Operation timeout in milliseconds (default: `30000`) |
-
-## Tool Discovery
-
-Since UDP doesn't support standardized discovery protocols, UTCP tools using UDP providers typically rely on:
-
-1. **Static Definition**: Tool definitions are provided in a separate JSON file or in the provider configuration
-2. **Companion HTTP Endpoint**: A companion HTTP endpoint (typically `/utcp`) that returns the tool definitions
-
-## Making Tool Calls
-
-When a tool associated with a UDP provider is called, the UTCP client will:
-
-1. Create a UDP socket
-2. Send the serialized input parameters to the specified host and port
-3. Wait for a response datagram (if expected)
-4. Process the response according to the tool's output schema
-5. Close the socket (unless connection pooling is used)
-
-## Protocol Considerations
-
-Since UDP is a connectionless, unreliable protocol:
-
-1. **Message Size**: UDP datagrams have size limitations (typically 65,507 bytes)
-2. **Reliability**: No guarantee of delivery, ordering, or duplicate protection
-3. **Statelessness**: Each message is independent and must contain all necessary context
-4. **Error Handling**: No built-in error reporting or retransmission
-
-## Examples
-
-### Sensor Data Collection
-
-```json
-{
- "name": "sensor_network",
- "provider_type": "udp",
- "host": "sensors.example.com",
- "port": 8125
-}
-```
-
-Tool definition:
-```json
-{
- "name": "send_reading",
- "description": "Send sensor reading to data collector",
- "inputs": {
- "type": "object",
- "properties": {
- "sensor_id": {
- "type": "string",
- "description": "Unique identifier for the sensor"
- },
- "reading": {
- "type": "number",
- "description": "Sensor reading value"
- },
- "unit": {
- "type": "string",
- "description": "Unit of measurement",
- "default": "C"
- },
- "timestamp": {
- "type": "string",
- "description": "ISO timestamp of reading"
- }
- },
- "required": ["sensor_id", "reading"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "success": {
- "type": "boolean",
- "description": "Whether the reading was recorded"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Message Size**: Keep messages small to avoid fragmentation
-2. **Idempotency**: Design tools to be idempotent to handle potential duplicate messages
-3. **Retry Logic**: Implement application-level retry logic for critical operations
-4. **Checksum Validation**: Consider adding application-level checksums to verify data integrity
-5. **Batch Processing**: Batch multiple small operations when appropriate to reduce overhead
-
-UDP providers are ideal for high-volume, low-latency applications where occasional packet loss is acceptable, such as metrics collection, real-time monitoring, and multiplayer games.
diff --git a/docs/providers/webrtc.md b/docs/providers/webrtc.md
deleted file mode 100644
index bd0c617..0000000
--- a/docs/providers/webrtc.md
+++ /dev/null
@@ -1,174 +0,0 @@
----
-id: webrtc
-title: WebRTC Provider
-sidebar_position: 10
----
-
-# WebRTC Provider (WIP)
-
-:::warning
-
-> This provider type is currently a Work In Progress (WIP) and may be subject to changes.
-:::
-The WebRTC provider enables UTCP to establish peer-to-peer connections for real-time communication, allowing for direct data exchange between clients without requiring a central server for data transfer.
-
-## Configuration
-
-WebRTC providers are configured using the following JSON structure:
-
-```json
-{
- "name": "p2p_service",
- "provider_type": "webrtc",
- "signaling_server": "wss://signaling.example.com/socket",
- "peer_id": "server-endpoint-123",
- "data_channel_name": "tools"
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"webrtc"` |
-| `signaling_server` | Yes | WebSocket URL of the signaling server |
-| `peer_id` | Yes | ID of the peer to connect to |
-| `data_channel_name` | No | Name of the data channel (default: `"tools"`) |
-
-## Signaling Process
-
-WebRTC requires a signaling mechanism to establish connections. The process typically works as follows:
-
-1. Both peers connect to the signaling server
-2. The client initiates a connection request with an offer
-3. The server responds with an answer
-4. ICE candidates are exchanged to establish the best connection path
-5. Once the connection is established, data flows directly between peers
-
-## Tool Discovery
-
-For WebRTC providers, tool discovery can happen in two ways:
-
-1. **Via Signaling Server**: The initial tool definitions are provided through the signaling server
-2. **After Connection**: Tool definitions are requested after the WebRTC connection is established
-
-## Making Tool Calls
-
-When a tool associated with a WebRTC provider is called, the UTCP client will:
-
-1. Establish or use an existing WebRTC connection to the specified peer
-2. Send the serialized input parameters through the data channel
-3. Wait for a response on the data channel
-4. Process the response according to the tool's output schema
-
-## Message Format
-
-Messages sent over the WebRTC data channel should follow a standard format:
-
-```json
-{
- "type": "tool_call",
- "tool": "tool_name",
- "id": "unique-call-id",
- "inputs": {
- "param1": "value1",
- "param2": "value2"
- }
-}
-```
-
-Responses follow a similar structure:
-
-```json
-{
- "type": "tool_response",
- "tool": "tool_name",
- "id": "unique-call-id",
- "output": {
- "result": "value"
- }
-}
-```
-
-## Examples
-
-### Collaborative Editing
-
-```json
-{
- "name": "document_collaboration",
- "provider_type": "webrtc",
- "signaling_server": "wss://collab.example.com/signal",
- "peer_id": "doc-server-456",
- "data_channel_name": "document"
-}
-```
-
-Tool definition:
-```json
-{
- "name": "sync_changes",
- "description": "Synchronize document changes with peers",
- "inputs": {
- "type": "object",
- "properties": {
- "document_id": {
- "type": "string",
- "description": "ID of the document being edited"
- },
- "changes": {
- "type": "array",
- "description": "List of changes to apply",
- "items": {
- "type": "object",
- "properties": {
- "op": {
- "type": "string",
- "enum": ["insert", "delete", "replace"]
- },
- "path": {
- "type": "string"
- },
- "value": {
- "type": "string"
- }
- }
- }
- },
- "revision": {
- "type": "integer",
- "description": "Current revision number"
- }
- },
- "required": ["document_id", "changes", "revision"]
- },
- "outputs": {
- "type": "object",
- "properties": {
- "success": {
- "type": "boolean",
- "description": "Whether the changes were applied"
- },
- "new_revision": {
- "type": "integer",
- "description": "New revision number"
- },
- "conflicts": {
- "type": "array",
- "description": "Conflicts that occurred, if any"
- }
- }
- }
-}
-```
-
-## Best Practices
-
-1. **Connection Management**: Maintain long-lived connections for frequent interactions
-2. **ICE Configuration**: Configure appropriate STUN/TURN servers for NAT traversal
-3. **Reliability**: Use reliable mode for the data channel when ordering and delivery guarantees are required
-4. **Security**: Use DTLS for encryption of WebRTC traffic
-5. **Fallback Mechanism**: Implement fallback to alternative providers if WebRTC connection fails
-
-WebRTC providers are ideal for peer-to-peer applications, real-time collaboration, and scenarios where direct communication between clients is preferable to routing through a server.
diff --git a/docs/providers/websocket.md b/docs/providers/websocket.md
deleted file mode 100644
index 3bee59a..0000000
--- a/docs/providers/websocket.md
+++ /dev/null
@@ -1,190 +0,0 @@
----
-id: websocket
-title: WebSocket Provider
-sidebar_position: 5
----
-
-# WebSocket Provider (WIP)
-
-:::warning
-
-> This provider type is currently a Work In Progress (WIP) and may be subject to changes.
-:::
-The WebSocket provider enables bidirectional, real-time communication between agents and tools, making it ideal for applications that require persistent connections and low-latency data exchange.
-
-## Configuration
-
-WebSocket providers are configured using the following JSON structure:
-
-```json
-{
- "name": "realtime_chat_service",
- "provider_type": "websocket",
- "url": "wss://api.example.com/socket",
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "token"
- }
-}
-```
-
-### Configuration Fields
-
-| Field | Required | Description |
-|-------|----------|-------------|
-| `name` | Yes | Unique identifier for the provider |
-| `provider_type` | Yes | Must be set to `"websocket"` |
-| `url` | Yes | WebSocket URL (`ws://` or `wss://`) |
-| `protocol` | No | WebSocket sub-protocol to use |
-| `keep_alive` | No | Whether to keep the connection alive (default: `true`) |
-| `auth` | No | Authentication configuration (if required) |
-| `headers` | No | Additional HTTP headers to include in the WebSocket handshake |
-| `header_fields` | No | List of input fields to be sent as request headers for the initial connection |
-
-## Tool Discovery
-
-Since WebSockets don't naturally support the request-response pattern needed for tool discovery, there are two approaches:
-
-1. **HTTP Discovery Endpoint**: Provide a separate HTTP endpoint (typically `/utcp`) that returns the tool definitions
-2. **Initial WebSocket Message**: After connecting, the client sends a discovery message and the server responds with tool definitions
-
-For the HTTP discovery approach:
-
-```json
-{
- "name": "realtime_chat_service",
- "provider_type": "websocket",
- "url": "wss://api.example.com/socket",
- "discovery_url": "https://api.example.com/utcp"
-}
-```
-
-## Message Format
-
-Messages sent over the WebSocket connection should follow a standard format:
-
-```json
-{
- "type": "call",
- "tool": "tool_name",
- "id": "unique_request_id",
- "params": {
- // Tool parameters go here
- }
-}
-```
-
-Response messages should include:
-
-```json
-{
- "type": "result",
- "id": "unique_request_id",
- "result": {
- // Tool result data goes here
- }
-}
-```
-
-For streaming results, the server can send multiple messages with the same `id` and a `partial: true` flag, with the final message having `partial: false`.
-
-## Authentication
-
-WebSocket providers typically handle authentication in one of these ways:
-
-1. **URL Query Parameters**: Adding authentication tokens to the URL
- ```
- wss://api.example.com/socket?token=YOUR_API_KEY
- ```
-
-2. **Authentication Message**: Sending credentials after connection is established
- ```json
- {
- "type": "auth",
- "token": "$YOUR_API_KEY"
- }
- ```
-
-3. **Headers (for initial HTTP handshake)**: Adding authentication headers to the WebSocket handshake
-
-## Making Tool Calls
-
-When a tool associated with a WebSocket provider is called, the UTCP client will:
-
-1. Establish a WebSocket connection to the specified URL (if not already connected)
-2. Send the tool call as a message over the connection
-3. Wait for the response message(s) that match the request ID
-4. Parse the response according to the tool's output schema
-
-## Examples
-
-### Chat Application
-
-```json
-{
- "name": "chat_service",
- "provider_type": "websocket",
- "url": "wss://chat.example.com/socket"
-}
-```
-
-Tool call:
-```json
-{
- "type": "call",
- "tool": "send_message",
- "id": "msg123",
- "params": {
- "channel": "general",
- "text": "Hello everyone!"
- }
-}
-```
-
-### Real-time Data Feed
-
-```json
-{
- "name": "market_data",
- "provider_type": "websocket",
- "url": "wss://markets.example.com/feed",
- "auth": {
- "auth_type": "api_key",
- "api_key": "$YOUR_API_KEY",
- "var_name": "token"
- }
-}
-```
-
-Subscription request:
-```json
-{
- "type": "call",
- "tool": "subscribe_ticker",
- "id": "sub456",
- "params": {
- "symbol": "AAPL",
- "fields": ["price", "volume"]
- }
-}
-```
-
-## Best Practices
-
-1. **Handle Reconnection**: Implement automatic reconnection with backoff strategy
-2. **Heartbeats**: Use ping/pong messages to keep connections alive
-3. **Message Ordering**: Track message IDs to handle out-of-order responses
-4. **Error Handling**: Define standard error message format and recovery procedures
-5. **Resource Management**: Limit the number of simultaneous connections
-
-## Common Issues
-
-| Issue | Solution |
-|-------|----------|
-| Connection drops | Implement automatic reconnection with exponential backoff |
-| Message ordering | Use sequence numbers or timestamps to track message order |
-| Connection limits | Pool WebSocket connections when possible |
-| Firewalls | Ensure WebSocket traffic is allowed (port 443 for WSS is usually open) |
-
-WebSocket providers offer significant advantages for real-time applications but require more complex client-side handling than simpler request-response protocols like HTTP.
diff --git a/docs/security.md b/docs/security.md
index 75dec3e..b182938 100644
--- a/docs/security.md
+++ b/docs/security.md
@@ -10,7 +10,7 @@ Security is a critical aspect of any protocol that enables tool access and execu
## Authentication
-UTCP supports several authentication methods across different provider types:
+UTCP supports several authentication methods across different communication protocol types:
### API Key Authentication
@@ -27,10 +27,6 @@ UTCP supports several authentication methods across different provider types:
The `location` field specifies where the API key is placed, and can be `header`, `query`, or `cookie`.
-- **Best Practice**: Store API keys securely and rotate them regularly
-- **Risk**: API keys in configuration files can be exposed if access controls are insufficient
-- **Mitigation**: Use environment variables or secure credential stores rather than hardcoding keys
-
### Basic Authentication
```json
@@ -43,10 +39,6 @@ The `location` field specifies where the API key is placed, and can be `header`,
}
```
-- **Best Practice**: Always use HTTPS when using Basic Authentication
-- **Risk**: Credentials are only Base64 encoded, not encrypted
-- **Mitigation**: Use OAuth2 or API keys instead when possible
-
### OAuth2 Authentication
```json
@@ -63,10 +55,6 @@ The `location` field specifies where the API key is placed, and can be `header`,
The `scope` field is optional and specifies the level of access that the client is requesting.
-- **Best Practice**: Implement proper token refresh and validation
-- **Risk**: Client secrets can be exposed in client-side applications
-- **Mitigation**: Use authorization code flow with PKCE for public clients
-
## Tool Access Control
When exposing tools through UTCP, consider implementing these access controls:
@@ -77,19 +65,17 @@ When exposing tools through UTCP, consider implementing these access controls:
4. **Usage Quotas**: Set maximum usage quotas for tools
5. **Audit Logging**: Log all tool calls for security monitoring
-## Provider-Specific Considerations
+## Communication Protocol-Specific Considerations
-### HTTP Provider
+### HTTP
- Always use HTTPS, never HTTP
-- Implement proper CORS policies if tools are called from browsers
-- Consider using request signing for additional security
-### CLI Provider
+### CLI
:::important
-CLI providers pose significant security risks as they execute commands on the local system.
+CLI poses a significant security risk as it executes commands on the local system.
:::
- Validate and sanitize all input parameters
@@ -97,11 +83,9 @@ CLI providers pose significant security risks as they execute commands on the lo
- Implement allow-lists for permitted commands
- Sandbox execution environments when possible
-### WebSocket Provider
+### WebSocket
- Use secure WebSocket (WSS) connections
-- Implement message authentication to prevent spoofing
-- Consider using per-message signatures for critical operations
## Data Protection
@@ -113,7 +97,7 @@ CLI providers pose significant security risks as they execute commands on the lo
## Secure Implementation Checklist
- [ ] Use HTTPS/WSS for all network communications
-- [ ] Implement proper authentication for all tool providers
+- [ ] Implement proper authentication for all communication protocols
- [ ] Validate all input against schemas before processing
- [ ] Sanitize inputs to prevent injection attacks
- [ ] Implement rate limiting to prevent abuse
diff --git a/docs/utcp-vs-mcp.md b/docs/utcp-vs-mcp.md
index 66c0c8a..3dec676 100644
--- a/docs/utcp-vs-mcp.md
+++ b/docs/utcp-vs-mcp.md
@@ -4,9 +4,9 @@ title: UTCP vs MCP
sidebar_position: 5
---
-# UTCP vs MCP: A Comparison
+# UTCP vs MCP tool calling: A Comparison
-This page compares the Universal Tool Calling Protocol (UTCP) with the Model Context Protocol (MCP), highlighting their different approaches to agent-tool integration.
+This page compares the Universal Tool Calling Protocol (UTCP) with the Model Context Protocol's (MCP) tool calling functionality, highlighting their different approaches to agent-tool integration.
## Video Overview
@@ -48,13 +48,13 @@ This eliminates the wrapper tax and allows organizations to expose their existin
| Feature | MCP | UTCP |
|---------|-----|------|
-| **Tool Discovery** | Via MCP Server | Via provider's discovery endpoint |
+| **Tool Discovery** | Via MCP Server | Via manual discovery endpoint |
| **Protocol Support** | HTTP Streaming | HTTP, WebSockets, gRPC, CLI, etc. |
| **Authentication** | Handled by MCP Server | Uses tool's native authentication |
-| **Streaming** | Native support | Supported via appropriate providers (SSE, WebSockets) |
+| **Streaming** | Native support | Supported via appropriate communication protocol (SSE, WebSockets) |
| **Implementation Complexity** | High (requires wrapper servers) | Low (simple JSON definitions) |
| **Performance** | Additional overhead due to proxy | Direct, native performance |
-| **Evolution Speed** | Slow (all participants must update) | Fast (individual providers can evolve independently) |
+| **Evolution Speed** | Slow (all participants must update) | Fast (individual communication protocols can evolve independently) |
## When to Choose Each Protocol
diff --git a/src/css/custom.css b/src/css/custom.css
index b06fccb..1d5f7e9 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -56,6 +56,10 @@ html, body {
color: #ffffff !important;
}
+details {
+ background-color: #000000 !important;
+}
+
/* Force all containers to be black */
.main-wrapper,
.navbar,
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth.md
new file mode 100644
index 0000000..67d971b
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth.md
@@ -0,0 +1,85 @@
+---
+title: auth
+sidebar_label: auth
+---
+
+# auth
+
+**File:** `core/src/utcp/data/auth.py`
+
+### class Auth {#auth}
+
+
+Documentation
+
+Authentication details for a provider.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier.
+
+
+#### Fields:
+
+- auth_type: str
+
+---
+
+### class AuthSerializer ([Serializer](./../interfaces/serializer.md#serializer)[Auth]) {#authserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for authentication details.
+
+Defines the contract for serializers that convert authentication details to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting authentication details to dictionaries for storage or transmission
+- Converting dictionaries back to authentication details
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- auth_serializers: dict[str, [Serializer](./../interfaces/serializer.md#serializer)[Auth]]
+
+#### Methods:
+
+
+to_dict(self, obj: Auth) -> dict
+
+Convert an Auth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The Auth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the Auth object.
+
+
+
+validate_dict(self, obj: dict) -> Auth
+
+Validate a dictionary and convert it to an Auth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The Auth object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
new file mode 100644
index 0000000..dedb21e
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
@@ -0,0 +1,84 @@
+---
+title: api_key_auth
+sidebar_label: api_key_auth
+---
+
+# api_key_auth
+
+**File:** `core/src/utcp/data/auth_implementations/api_key_auth.py`
+
+### class ApiKeyAuth ([Auth](./../auth.md#auth)) {#apikeyauth}
+
+
+Documentation
+
+Authentication using an API key.
+
+The key can be provided directly or sourced from an environment variable.
+Supports placement in headers, query parameters, or cookies.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "api_key".
+- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '${}' are
+ treated as an injected variable from environment or configuration.
+- **`var_name`**: The name of the header, query parameter, or cookie that
+ contains the API key.
+- **`location`**: Where to include the API key (header, query parameter, or cookie).
+
+
+#### Fields:
+
+- auth_type: Literal['api_key']
+- api_key: str
+- var_name: str
+- location: Literal['header', 'query', 'cookie']
+
+---
+
+### class ApiKeyAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[ApiKeyAuth]) {#apikeyauthserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for ApiKeyAuth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: ApiKeyAuth) -> dict
+
+Convert an ApiKeyAuth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The ApiKeyAuth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the ApiKeyAuth object.
+
+
+
+validate_dict(self, obj: dict) -> ApiKeyAuth
+
+Validate a dictionary and convert it to an ApiKeyAuth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The ApiKeyAuth object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
new file mode 100644
index 0000000..87f89ea
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
@@ -0,0 +1,80 @@
+---
+title: basic_auth
+sidebar_label: basic_auth
+---
+
+# basic_auth
+
+**File:** `core/src/utcp/data/auth_implementations/basic_auth.py`
+
+### class BasicAuth ([Auth](./../auth.md#auth)) {#basicauth}
+
+
+Documentation
+
+Authentication using HTTP Basic Authentication.
+
+Uses the standard HTTP Basic Authentication scheme with username and password
+encoded in the Authorization header.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "basic".
+- **`username`**: The username for basic authentication. Recommended to use injected variables.
+- **`password`**: The password for basic authentication. Recommended to use injected variables.
+
+
+#### Fields:
+
+- auth_type: Literal['basic']
+- username: str
+- password: str
+
+---
+
+### class BasicAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[BasicAuth]) {#basicauthserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for BasicAuth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: BasicAuth) -> dict
+
+Convert a BasicAuth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The BasicAuth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the BasicAuth object.
+
+
+
+validate_dict(self, obj: dict) -> BasicAuth
+
+Validate a dictionary and convert it to a BasicAuth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The BasicAuth object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
new file mode 100644
index 0000000..9fe3024
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
@@ -0,0 +1,84 @@
+---
+title: oauth2_auth
+sidebar_label: oauth2_auth
+---
+
+# oauth2_auth
+
+**File:** `core/src/utcp/data/auth_implementations/oauth2_auth.py`
+
+### class OAuth2Auth ([Auth](./../auth.md#auth)) {#oauth2auth}
+
+
+Documentation
+
+Authentication using OAuth2 client credentials flow.
+
+Implements the OAuth2 client credentials grant type for machine-to-machine
+authentication. The client automatically handles token acquisition and refresh.
+
+
+**Attributes**
+
+- **`auth_type`**: The authentication type identifier, always "oauth2".
+- **`token_url`**: The URL endpoint to fetch the OAuth2 access token from. Recommended to use injected variables.
+- **`client_id`**: The OAuth2 client identifier. Recommended to use injected variables.
+- **`client_secret`**: The OAuth2 client secret. Recommended to use injected variables.
+- **`scope`**: Optional scope parameter to limit the access token's permissions.
+
+
+#### Fields:
+
+- auth_type: Literal['oauth2']
+- token_url: str
+- client_id: str
+- client_secret: str
+- scope: Optional[str]
+
+---
+
+### class OAuth2AuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[OAuth2Auth]) {#oauth2authserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for OAuth2Auth model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: OAuth2Auth) -> dict
+
+Convert an OAuth2Auth object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The OAuth2Auth object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the OAuth2Auth object.
+
+
+
+validate_dict(self, obj: dict) -> OAuth2Auth
+
+Validate a dictionary and convert it to an OAuth2Auth object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The OAuth2Auth object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/call_template.md b/versioned_docs/version-1.0/api/core/utcp/data/call_template.md
new file mode 100644
index 0000000..37af01a
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/call_template.md
@@ -0,0 +1,93 @@
+---
+title: call_template
+sidebar_label: call_template
+---
+
+# call_template
+
+**File:** `core/src/utcp/data/call_template.py`
+
+### class CallTemplate {#calltemplate}
+
+
+Documentation
+
+Base class for all UTCP tool providers.
+
+This is the abstract base class that all specific call template implementations
+inherit from. It provides the common fields that every provider must have.
+
+
+**Attributes**
+
+- **`name`**: Unique identifier for the provider. Defaults to a random UUID hex string.
+ Should be unique across all providers and recommended to be set to a human-readable name.
+ Can only contain letters, numbers and underscores. All special characters must be replaced with underscores.
+- **`call_template_type`**: The transport protocol type used by this provider.
+
+
+#### Fields:
+
+- name: str
+- call_template_type: str
+- auth: Optional[[Auth](./auth.md#auth)]
+
+---
+
+### class CallTemplateSerializer ([Serializer](./../interfaces/serializer.md#serializer)[CallTemplate]) {#calltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for call templates.
+
+Defines the contract for serializers that convert call templates to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting call templates to dictionaries for storage or transmission
+- Converting dictionaries back to call templates
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- call_template_serializers: dict[str, [Serializer](./../interfaces/serializer.md#serializer)[CallTemplate]]
+
+#### Methods:
+
+
+to_dict(self, obj: CallTemplate) -> dict
+
+Convert a CallTemplate object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The CallTemplate object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the CallTemplate object.
+
+
+
+validate_dict(self, obj: dict) -> CallTemplate
+
+Validate a dictionary and convert it to a CallTemplate object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The CallTemplate object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/register_manual_response.md b/versioned_docs/version-1.0/api/core/utcp/data/register_manual_response.md
new file mode 100644
index 0000000..86102db
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/register_manual_response.md
@@ -0,0 +1,33 @@
+---
+title: register_manual_response
+sidebar_label: register_manual_response
+---
+
+# register_manual_response
+
+**File:** `core/src/utcp/data/register_manual_response.py`
+
+### class RegisterManualResult {#registermanualresult}
+
+
+Documentation
+
+Result of a manual registration.
+
+
+**Attributes**
+
+- **`manual_call_template`**: The call template of the registered manual.
+- **`manual`**: The registered manual.
+- **`success`**: Whether the registration was successful.
+- **`errors`**: List of error messages if registration failed.
+
+
+#### Fields:
+
+- manual_call_template: [CallTemplate](./call_template.md#calltemplate)
+- manual: [UtcpManual](./utcp_manual.md#utcpmanual)
+- success: bool
+- errors: List[str]
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/tool.md b/versioned_docs/version-1.0/api/core/utcp/data/tool.md
new file mode 100644
index 0000000..549fc37
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/tool.md
@@ -0,0 +1,200 @@
+---
+title: tool
+sidebar_label: tool
+---
+
+# tool
+
+**File:** `core/src/utcp/data/tool.py`
+
+### class JsonSchema {#jsonschema}
+
+
+Documentation
+
+JSON Schema for tool inputs and outputs.
+
+
+**Attributes**
+
+- **`schema_`**: Optional schema identifier.
+- **`id_`**: Optional schema identifier.
+- **`title`**: Optional schema title.
+- **`description`**: Optional schema description.
+- **`type`**: Optional schema type.
+- **`properties`**: Optional schema properties.
+- **`items`**: Optional schema items.
+- **`required`**: Optional schema required fields.
+- **`enum`**: Optional schema enum values.
+- **`const`**: Optional schema constant value.
+- **`default`**: Optional schema default value.
+- **`format`**: Optional schema format.
+- **`additionalProperties`**: Optional schema additional properties.
+
+
+#### Fields:
+
+- schema_: Optional[str]
+- id_: Optional[str]
+- title: Optional[str]
+- description: Optional[str]
+- type: Optional[Union[str, List[str]]]
+- properties: Optional[Dict[str, 'JsonSchema']]
+- items: Optional[Union['JsonSchema', List['JsonSchema']]]
+- required: Optional[List[str]]
+- enum: Optional[List[JsonType]]
+- const: Optional[JsonType]
+- default: Optional[JsonType]
+- format: Optional[str]
+- additionalProperties: Optional[Union[bool, 'JsonSchema']]
+- pattern: Optional[str]
+- minimum: Optional[float]
+- maximum: Optional[float]
+- minLength: Optional[int]
+- maxLength: Optional[int]
+- `model_config`
+
+---
+
+### class JsonSchemaSerializer ([Serializer](./../interfaces/serializer.md#serializer)[JsonSchema]) {#jsonschemaserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for JSON Schema.
+
+Defines the contract for serializers that convert JSON Schema to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting JSON Schema to dictionaries for storage or transmission
+- Converting dictionaries back to JSON Schema
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: JsonSchema) -> dict
+
+Convert a JsonSchema object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The JsonSchema object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the JsonSchema object.
+
+
+
+validate_dict(self, obj: dict) -> JsonSchema
+
+Validate a dictionary and convert it to a JsonSchema object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The JsonSchema object converted from the dictionary.
+
+
+---
+
+### class Tool {#tool}
+
+
+Documentation
+
+Definition of a UTCP tool.
+
+Represents a callable tool with its metadata, input/output schemas,
+and provider configuration. Tools are the fundamental units of
+functionality in the UTCP ecosystem.
+
+
+**Attributes**
+
+- **`name`**: Unique identifier for the tool, typically in format "provider.tool_name".
+- **`description`**: Human-readable description of what the tool does.
+- **`inputs`**: JSON Schema defining the tool's input parameters.
+- **`outputs`**: JSON Schema defining the tool's return value structure.
+- **`tags`**: List of tags for categorization and search.
+- **`average_response_size`**: Optional hint about typical response size in bytes.
+- **`tool_call_template`**: [CallTemplate](./call_template.md#calltemplate) configuration for accessing this tool.
+
+
+#### Fields:
+
+- name: str
+- description: str
+- inputs: JsonSchema
+- outputs: JsonSchema
+- tags: List[str]
+- average_response_size: Optional[int]
+- tool_call_template: [CallTemplate](./call_template.md#calltemplate)
+
+---
+
+### class ToolSerializer ([Serializer](./../interfaces/serializer.md#serializer)[Tool]) {#toolserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for tools.
+
+Defines the contract for serializers that convert tools to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tools to dictionaries for storage or transmission
+- Converting dictionaries back to tools
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: Tool) -> dict
+
+Convert a Tool object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The Tool object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the Tool object.
+
+
+
+validate_dict(self, obj: dict) -> Tool
+
+Validate a dictionary and convert it to a Tool object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The Tool object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/utcp_client_config.md b/versioned_docs/version-1.0/api/core/utcp/data/utcp_client_config.md
new file mode 100644
index 0000000..5f0a6c7
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/utcp_client_config.md
@@ -0,0 +1,128 @@
+---
+title: utcp_client_config
+sidebar_label: utcp_client_config
+---
+
+# utcp_client_config
+
+**File:** `core/src/utcp/data/utcp_client_config.py`
+
+### class UtcpClientConfig {#utcpclientconfig}
+
+
+Documentation
+
+Configuration model for UTCP client setup.
+
+Provides comprehensive configuration options for UTCP clients including
+variable definitions, provider file locations, and variable loading
+mechanisms. Supports hierarchical variable resolution with multiple
+sources.
+
+
+**Variable Resolution Order**
+
+1. Direct variables dictionary
+2. Custom variable loaders (in order)
+3. Environment variables
+
+
+
+**Attributes**
+
+variables for substitution.
+variable loader configurations for loading variables from external
+sources like .env files or remote services.
+repository, which manages the storage and retrieval of tools.
+Defaults to an in-memory repository.
+search strategy, defining how tools are looked up. Defaults to a
+tag and description-based search.
+configurations to be applied after a tool call.
+call templates for registering tools that don't have a provider.
+
+
+
+**Example**
+
+```python
+ config = UtcpClientConfig(
+ variables={"MANUAL__NAME_API_KEY_NAME": "$REMAPPED_API_KEY"},
+ load_variables_from=[
+ VariableLoaderSerializer().validate_dict({"variable_loader_type": "dotenv", "env_file_path": ".env"})
+ ],
+ tool_repository={
+ "tool_repository_type": "in_memory"
+ },
+ tool_search_strategy={
+ "tool_search_strategy_type": "tag_and_description_word_match"
+ },
+ post_processing=[],
+ manual_call_templates=[]
+ )
+```
+
+
+#### Fields:
+
+- variables: Optional[Dict[str, str]]
+- load_variables_from: Optional[List[[VariableLoader](./variable_loader.md#variableloader)]]
+- tool_repository: [ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)
+- tool_search_strategy: [ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)
+- post_processing: List[[ToolPostProcessor](./../interfaces/tool_post_processor.md#toolpostprocessor)]
+- manual_call_templates: List[[CallTemplate](./call_template.md#calltemplate)]
+
+---
+
+### class UtcpClientConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpClientConfig]) {#utcpclientconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for UTCP client configurations.
+
+Defines the contract for serializers that convert UTCP client configurations to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting UTCP client configurations to dictionaries for storage or transmission
+- Converting dictionaries back to UTCP client configurations
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+to_dict(self, obj: UtcpClientConfig) -> dict
+
+Convert a UtcpClientConfig object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The UtcpClientConfig object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the UtcpClientConfig object.
+
+
+
+validate_dict(self, data: dict) -> UtcpClientConfig
+
+Validate a dictionary and convert it to a UtcpClientConfig object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The UtcpClientConfig object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md b/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
new file mode 100644
index 0000000..10633e2
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
@@ -0,0 +1,115 @@
+---
+title: utcp_manual
+sidebar_label: utcp_manual
+---
+
+# utcp_manual
+
+**File:** `core/src/utcp/data/utcp_manual.py`
+
+### class UtcpManual {#utcpmanual}
+
+
+Documentation
+
+Standard format for tool provider responses during discovery.
+
+Represents the complete set of tools available from a provider, along
+with version information for compatibility checking. This format is
+returned by tool providers when clients query for available tools
+(e.g., through the `/utcp` endpoint or similar discovery mechanisms).
+
+The manual serves as the authoritative source of truth for what tools
+a provider offers and how they should be invoked.
+
+
+**Attributes**
+
+- **`version`**: UTCP protocol version supported by the provider.
+ Defaults to the current library version.
+- **`tools`**: List of available tools with their complete configurations
+ including input/output schemas, descriptions, and metadata.
+
+
+
+**Example**
+
+```python
+ @utcp_tool
+
+
+**Def Tool1()**
+
+pass
+
+@utcp_tool
+
+
+**Def Tool2()**
+
+pass
+
+# Create a manual from registered tools
+manual = UtcpManual.create_from_decorators()
+
+# Manual with specific tools
+manual = UtcpManual.create_from_decorators(
+manual_version="1.0.0",
+exclude=["tool1"]
+)
+```
+
+
+#### Fields:
+
+- utcp_version: str
+- manual_version: str
+- tools: List[[Tool](./tool.md#tool)]
+
+---
+
+### class UtcpManualSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpManual]) {#utcpmanualserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for UtcpManual model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: UtcpManual) -> dict
+
+Convert a UtcpManual object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The UtcpManual object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the UtcpManual object.
+
+
+
+validate_dict(self, data: dict) -> UtcpManual
+
+Validate a dictionary and convert it to a UtcpManual object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The UtcpManual object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
new file mode 100644
index 0000000..397eb6b
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
@@ -0,0 +1,101 @@
+---
+title: variable_loader
+sidebar_label: variable_loader
+---
+
+# variable_loader
+
+**File:** `core/src/utcp/data/variable_loader.py`
+
+### class VariableLoader {#variableloader}
+
+
+Documentation
+
+Abstract base class for variable loading configurations.
+
+Defines the interface for variable loaders that can retrieve variable
+values from different sources such as files, databases, or external
+services. Implementations provide specific loading mechanisms while
+maintaining a consistent interface.
+
+
+**Attributes**
+
+- **`variable_loader_type`**: Type identifier for the variable loader.
+
+
+#### Fields:
+
+- variable_loader_type: str
+
+#### Methods:
+
+
+get(self, key: str) -> Optional[str]
+
+Retrieve a variable value by key.
+
+
+**Args**
+
+- **`key`**: Variable name to retrieve.
+
+
+
+**Returns**
+
+Variable value if found, None otherwise.
+
+
+---
+
+### class VariableLoaderSerializer ([Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]) {#variableloaderserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for VariableLoader model.
+
+
+#### Fields:
+
+- loader_serializers: Dict[str, Type[[Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]]]
+
+#### Methods:
+
+
+to_dict(self, obj: VariableLoader) -> dict
+
+Convert a VariableLoader object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The VariableLoader object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the VariableLoader object.
+
+
+
+validate_dict(self, data: dict) -> VariableLoader
+
+Validate a dictionary and convert it to a VariableLoader object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The VariableLoader object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
new file mode 100644
index 0000000..7006cd1
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
@@ -0,0 +1,106 @@
+---
+title: dot_env_variable_loader
+sidebar_label: dot_env_variable_loader
+---
+
+# dot_env_variable_loader
+
+**File:** `core/src/utcp/data/variable_loader_implementations/dot_env_variable_loader.py`
+
+### class DotEnvVariableLoader ([VariableLoader](./../variable_loader.md#variableloader)) {#dotenvvariableloader}
+
+
+Documentation
+
+Environment file variable loader implementation.
+
+Loads variables from .env files using the dotenv format. This loader
+supports the standard key=value format with optional quoting and
+comment support provided by the python-dotenv library.
+
+
+**Attributes**
+
+- **`env_file_path`**: Path to the .env file to load variables from.
+
+
+
+**Example**
+
+```python
+ loader = DotEnvVariableLoader(env_file_path=".env")
+ api_key = loader.get("API_KEY")
+```
+
+
+#### Fields:
+
+- variable_loader_type: Literal['dotenv']
+- env_file_path: str
+
+#### Methods:
+
+
+get(self, key: str) -> Optional[str]
+
+Load a variable from the configured .env file.
+
+
+**Args**
+
+- **`key`**: Variable name to retrieve from the environment file.
+
+
+
+**Returns**
+
+Variable value if found in the file, None otherwise.
+
+
+---
+
+### class DotEnvVariableLoaderSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[DotEnvVariableLoader]) {#dotenvvariableloaderserializer}
+
+
+Documentation
+
+[Serializer](./../../interfaces/serializer.md#serializer) for DotEnvVariableLoader model.
+
+
+#### Methods:
+
+
+to_dict(self, obj: DotEnvVariableLoader) -> dict
+
+Convert a DotEnvVariableLoader object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The DotEnvVariableLoader object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the DotEnvVariableLoader object.
+
+
+
+validate_dict(self, data: dict) -> DotEnvVariableLoader
+
+Validate a dictionary and convert it to a DotEnvVariableLoader object.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The DotEnvVariableLoader object converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
new file mode 100644
index 0000000..dd4e59e
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
@@ -0,0 +1,18 @@
+---
+title: utcp_serializer_validation_error
+sidebar_label: utcp_serializer_validation_error
+---
+
+# utcp_serializer_validation_error
+
+**File:** `core/src/utcp/exceptions/utcp_serializer_validation_error.py`
+
+### class UtcpSerializerValidationError {#utcpserializervalidationerror}
+
+
+Documentation
+
+Exception raised when a serializer validation fails.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_variable_not_found_exception.md b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
new file mode 100644
index 0000000..ee5ec1f
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_variable_not_found_exception.md
@@ -0,0 +1,45 @@
+---
+title: utcp_variable_not_found_exception
+sidebar_label: utcp_variable_not_found_exception
+---
+
+# utcp_variable_not_found_exception
+
+**File:** `core/src/utcp/exceptions/utcp_variable_not_found_exception.py`
+
+### class UtcpVariableNotFound {#utcpvariablenotfound}
+
+
+Documentation
+
+Exception raised when a required variable cannot be found.
+
+This exception is thrown during variable substitution when a referenced
+variable cannot be resolved through any of the configured variable sources.
+It provides information about which variable was missing to help with
+debugging configuration issues.
+
+
+**Attributes**
+
+- **`variable_name`**: The name of the variable that could not be found.
+
+
+#### Fields:
+
+- variable_name: str
+
+#### Methods:
+
+
+__init__(self, variable_name: str)
+
+Initialize the exception with the missing variable name.
+
+
+**Args**
+
+- **`variable_name`**: Name of the variable that could not be found.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md b/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
new file mode 100644
index 0000000..1300ef6
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
@@ -0,0 +1,132 @@
+---
+title: default_variable_substitutor
+sidebar_label: default_variable_substitutor
+---
+
+# default_variable_substitutor
+
+**File:** `core/src/utcp/implementations/default_variable_substitutor.py`
+
+### class DefaultVariableSubstitutor ([VariableSubstitutor](./../interfaces/variable_substitutor.md#variablesubstitutor)) {#defaultvariablesubstitutor}
+
+
+Documentation
+
+Default implementation of variable substitution.
+
+Provides a hierarchical variable resolution system that searches for
+
+**Variables In The Following Order**
+
+1. Configuration variables (exact match)
+2. Custom variable loaders (in order)
+3. Environment variables
+
+
+
+**Features**
+
+- Provider-specific variable namespacing
+- Hierarchical variable resolution
+- Recursive substitution in nested data structures
+- Variable discovery for validation
+
+
+
+**Variable Namespacing**
+
+Provider-specific variables are prefixed with the provider name
+to avoid conflicts. For example, a variable 'api_key' for provider
+'web_scraper' becomes 'web__scraper_api_key' internally.
+
+
+#### Methods:
+
+
+substitute(self, obj: dict | list | str, config: [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig), variable_namespace: Optional[str]) -> Any
+
+Recursively substitute variables in nested data structures.
+
+Performs deep substitution on dictionaries, lists, and strings.
+Non-string types are returned unchanged. String values are scanned
+for variable references using ${VAR} and $VAR syntax.
+
+
+**Args**
+
+- **`obj`**: Object to perform substitution on. Can be any type.
+- **`config`**: UTCP client configuration containing variable sources.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+Object with all variable references replaced. Structure and
+non-string values are preserved.
+
+
+
+**Raises**
+
+- **`[UtcpVariableNotFound](./../exceptions/utcp_variable_not_found_exception.md#utcpvariablenotfound)`**: If any referenced variable cannot be resolved.
+- **`ValueError`**: If variable_namespace contains invalid characters.
+
+
+
+**Example**
+
+```python
+ substitutor = DefaultVariableSubstitutor()
+ result = substitutor.substitute(
+ {"url": "https://${HOST}/api", "port": 8080},
+ config,
+ "my_provider"
+ )
+ # Returns: {"url": "https://api.example.com/api", "port": 8080}
+```
+
+
+
+find_required_variables(self, obj: dict | list | str, variable_namespace: Optional[str]) -> List[str]
+
+Recursively discover all variable references in a data structure.
+
+Scans the object for variable references using ${VAR} and $VAR syntax,
+returning fully-qualified variable names with variable namespacing.
+Useful for validation and dependency analysis.
+
+
+**Args**
+
+- **`obj`**: Object to scan for variable references.
+- **`variable_namespace`**: Variable namespace used for variable namespacing.
+ Variable names are prefixed with this variable namespace.
+
+
+
+**Raises**
+
+- **`ValueError`**: If variable_namespace contains invalid characters.
+
+
+
+**Returns**
+
+List of fully-qualified variable names found in the object.
+
+
+
+**Example**
+
+```python
+ substitutor = DefaultVariableSubstitutor()
+ vars = substitutor.find_required_variables(
+ {"url": "https://${HOST}/api", "key": "$API_KEY"},
+ "web_api"
+ )
+ # Returns: ["web__api_HOST", "web__api_API_KEY"]
+```
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md b/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
new file mode 100644
index 0000000..b8e39c6
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
@@ -0,0 +1,219 @@
+---
+title: in_mem_tool_repository
+sidebar_label: in_mem_tool_repository
+---
+
+# in_mem_tool_repository
+
+**File:** `core/src/utcp/implementations/in_mem_tool_repository.py`
+
+### class InMemToolRepository ([ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)) {#inmemtoolrepository}
+
+
+Documentation
+
+Thread-safe in-memory implementation of `[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)`.
+
+Stores tools and their associated manual call templates in dictionaries and
+protects all operations with a read-write lock to ensure consistency under
+concurrency while allowing multiple concurrent readers.
+
+
+#### Methods:
+
+
+async save_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate), manual: [UtcpManual](./../data/utcp_manual.md#utcpmanual)) -> None
+
+Save a manual and its associated tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The manual call template to save.
+- **`manual`**: The manual to save.
+
+
+
+async remove_manual(self, manual_name: str) -> bool
+
+Remove a manual and its associated tools.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to remove.
+
+
+
+**Returns**
+
+True if the manual was removed, False otherwise.
+
+
+
+async remove_tool(self, tool_name: str) -> bool
+
+Remove a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to remove.
+
+
+
+**Returns**
+
+True if the tool was removed, False otherwise.
+
+
+
+async get_tool(self, tool_name: str) -> Optional[[Tool](./../data/tool.md#tool)]
+
+Get a tool by name.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to get.
+
+
+
+**Returns**
+
+The tool if it exists, None otherwise.
+
+
+
+async get_tools(self) -> List[[Tool](./../data/tool.md#tool)]
+
+Get all tools in the repository.
+
+
+**Returns**
+
+A list of all tools in the repository.
+
+
+
+async get_tools_by_manual(self, manual_name: str) -> Optional[List[[Tool](./../data/tool.md#tool)]]
+
+Get all tools associated with a manual.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to get tools for.
+
+
+
+**Returns**
+
+A list of tools associated with the manual, or None if the manual does not exist.
+
+
+
+async get_manual(self, manual_name: str) -> Optional[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get a manual by name.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to get.
+
+
+
+**Returns**
+
+The manual if it exists, None otherwise.
+
+
+
+async get_manuals(self) -> List[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get all manuals in the repository.
+
+
+**Returns**
+
+A list of all manuals in the repository.
+
+
+
+async get_manual_call_template(self, manual_call_template_name: str) -> Optional[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get a manual call template by name.
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the manual call template to get.
+
+
+
+**Returns**
+
+The manual call template if it exists, None otherwise.
+
+
+
+async get_manual_call_templates(self) -> List[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get all manual call templates in the repository.
+
+
+**Returns**
+
+A list of all manual call templates in the repository.
+
+
+---
+
+### class InMemToolRepositoryConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[InMemToolRepository]) {#inmemtoolrepositoryconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for `InMemToolRepository`.
+
+Converts an `InMemToolRepository` instance to a dictionary and vice versa.
+
+
+#### Methods:
+
+
+to_dict(self, obj: InMemToolRepository) -> dict
+
+Convert an `InMemToolRepository` instance to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The `InMemToolRepository` instance to convert.
+
+
+
+**Returns**
+
+A dictionary representing the `InMemToolRepository` instance.
+
+
+
+validate_dict(self, data: dict) -> InMemToolRepository
+
+Convert a dictionary to an `InMemToolRepository` instance.
+
+
+**Args**
+
+- **`data`**: The dictionary to convert.
+
+
+
+**Returns**
+
+An `InMemToolRepository` instance representing the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md b/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
new file mode 100644
index 0000000..63dcc22
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
@@ -0,0 +1,96 @@
+---
+title: tag_search
+sidebar_label: tag_search
+---
+
+# tag_search
+
+**File:** `core/src/utcp/implementations/tag_search.py`
+
+### class TagAndDescriptionWordMatchStrategy ([ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)) {#taganddescriptionwordmatchstrategy}
+
+
+Documentation
+
+Tag and description word match strategy.
+
+This strategy matches tools based on the presence of tags and words in the description.
+
+
+#### Fields:
+
+- tool_search_strategy_type: Literal['tag_and_description_word_match']
+- description_weight: float
+- tag_weight: float
+
+#### Methods:
+
+
+async search_tools(self, tool_repository: [ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository), query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools based on the given query.
+
+
+**Args**
+
+- **`tool_repository`**: The tool repository to search in.
+- **`query`**: The query to search for.
+- **`limit`**: The maximum number of results to return.
+- **`any_of_tags_required`**: A list of tags that must be present in the tool.
+
+
+
+**Returns**
+
+A list of tools that match the query.
+
+
+---
+
+### class TagAndDescriptionWordMatchStrategyConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[TagAndDescriptionWordMatchStrategy]) {#taganddescriptionwordmatchstrategyconfigserializer}
+
+
+Documentation
+
+[Serializer](./../interfaces/serializer.md#serializer) for `TagAndDescriptionWordMatchStrategy`.
+
+Converts a `TagAndDescriptionWordMatchStrategy` instance to a dictionary and vice versa.
+
+
+#### Methods:
+
+
+to_dict(self, obj: TagAndDescriptionWordMatchStrategy) -> dict
+
+Convert a `TagAndDescriptionWordMatchStrategy` instance to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The `TagAndDescriptionWordMatchStrategy` instance to convert.
+
+
+
+**Returns**
+
+A dictionary representing the `TagAndDescriptionWordMatchStrategy` instance.
+
+
+
+validate_dict(self, data: dict) -> TagAndDescriptionWordMatchStrategy
+
+Convert a dictionary to a `TagAndDescriptionWordMatchStrategy` instance.
+
+
+**Args**
+
+- **`data`**: The dictionary to convert.
+
+
+
+**Returns**
+
+A `TagAndDescriptionWordMatchStrategy` instance representing the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md b/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
new file mode 100644
index 0000000..b969a77
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
@@ -0,0 +1,180 @@
+---
+title: utcp_client_implementation
+sidebar_label: utcp_client_implementation
+---
+
+# utcp_client_implementation
+
+**File:** `core/src/utcp/implementations/utcp_client_implementation.py`
+
+### class UtcpClientImplementation ([UtcpClient](./../utcp_client.md#utcpclient)) {#utcpclientimplementation}
+
+
+Documentation
+
+Implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
+
+This class provides a concrete implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
+
+
+#### Methods:
+
+
+async create(cls, root_dir: Optional[str], config: Optional[Union[str, Dict[str, Any], [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig)]]) -> '[UtcpClient](./../utcp_client.md#utcpclient)'
+
+Create a new `[UtcpClient](./../utcp_client.md#utcpclient)` instance.
+
+
+**Args**
+
+- **`root_dir`**: The root directory for the client.
+- **`config`**: The configuration for the client.
+
+
+
+**Returns**
+
+A new `[UtcpClient](./../utcp_client.md#utcpclient)` instance.
+
+
+
+async register_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> [RegisterManualResult](./../data/register_manual_response.md#registermanualresult)
+
+Register a manual in the client.
+
+
+**Args**
+
+- **`manual_call_template`**: The `[CallTemplate](./../data/call_template.md#calltemplate)` instance representing the manual to register.
+
+
+
+**Returns**
+
+A `[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)` instance representing the result of the registration.
+
+
+
+async register_manuals(self, manual_call_templates: List[[CallTemplate](./../data/call_template.md#calltemplate)]) -> List[[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)]
+
+Register multiple manuals in the client.
+
+
+**Args**
+
+- **`manual_call_templates`**: A list of `[CallTemplate](./../data/call_template.md#calltemplate)` instances representing the manuals to register.
+
+
+
+**Returns**
+
+A list of `[RegisterManualResult](./../data/register_manual_response.md#registermanualresult)` instances representing the results of the registration.
+
+
+
+async deregister_manual(self, manual_name: str) -> bool
+
+Deregister a manual from the client.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to deregister.
+
+
+
+**Returns**
+
+A boolean indicating whether the manual was successfully deregistered.
+
+
+
+async call_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> Any
+
+Call a tool in the client.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: A dictionary of arguments to pass to the tool.
+
+
+
+**Returns**
+
+The result of the tool call.
+
+
+
+async call_tool_streaming(self, tool_name: str, tool_args: Dict[str, Any]) -> AsyncGenerator[Any, None]
+
+Call a tool in the client streamingly.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: A dictionary of arguments to pass to the tool.
+
+
+
+**Returns**
+
+An async generator yielding the result of the tool call.
+
+
+
+async search_tools(self, query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools based on the given query.
+
+
+**Args**
+
+- **`query`**: The query to search for.
+- **`limit`**: The maximum number of results to return.
+- **`any_of_tags_required`**: A list of tags that must be present in the tool.
+
+
+
+**Returns**
+
+A list of tools that match the query.
+
+
+
+async get_required_variables_for_manual_and_tools(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> List[str]
+
+Get the required variables for a manual and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The `[CallTemplate](./../data/call_template.md#calltemplate)` instance representing the manual.
+
+
+
+**Returns**
+
+A list of required variables for the manual and its tools.
+
+
+
+async get_required_variables_for_registered_tool(self, tool_name: str) -> List[str]
+
+Get the required variables for a registered tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool.
+
+
+
+**Returns**
+
+A list of required variables for the tool.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/communication_protocol.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/communication_protocol.md
new file mode 100644
index 0000000..9ec814e
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/communication_protocol.md
@@ -0,0 +1,152 @@
+---
+title: communication_protocol
+sidebar_label: communication_protocol
+---
+
+# communication_protocol
+
+**File:** `core/src/utcp/interfaces/communication_protocol.py`
+
+### class CommunicationProtocol {#communicationprotocol}
+
+
+Documentation
+
+Abstract interface for UTCP client transport implementations.
+
+Defines the contract that all transport implementations must follow to
+integrate with the UTCP client. Each transport handles communication
+with a specific type of provider (HTTP, CLI, WebSocket, etc.).
+
+
+**Transport Implementations Are Responsible For**
+
+- Discovering available tools from providers
+- Managing provider lifecycle (registration/deregistration)
+- Executing tool calls through the appropriate protocol
+
+
+#### Fields:
+
+- communication_protocols: dict[str, 'CommunicationProtocol']
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> [RegisterManualResult](./../data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools.
+
+Connects to the provider and retrieves the list of tools it offers.
+This may involve making discovery requests, parsing configuration files,
+or initializing connections depending on the provider type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to register.
+
+
+
+**Returns**
+
+[RegisterManualResult](./../data/register_manual_response.md#registermanualresult) object containing the call template and manual.
+
+
+
+**Raises**
+
+- **`ConnectionError`**: If unable to connect to the provider.
+- **`ValueError`**: If the provider configuration is invalid.
+
+
+
+async deregister_manual(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> None
+
+Deregister a manual and its tools.
+
+Cleanly disconnects from the provider and releases any associated
+resources such as connections, processes, or file handles.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to deregister.
+
+
+
+**Note**
+
+Should handle cases where the provider is already disconnected
+or was never properly registered.
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through this transport.
+
+Sends a tool invocation request to the provider using the appropriate
+protocol and returns the result. Handles serialization of arguments
+and deserialization of responses according to the transport type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+The tool's response, with type depending on the tool's output schema.
+
+
+
+**Raises**
+
+- **`ToolNotFoundError`**: If the specified tool doesn't exist.
+- **`ValidationError`**: If the arguments don't match the tool's input schema.
+- **`ConnectionError`**: If unable to communicate with the provider.
+- **`TimeoutError`**: If the tool call exceeds the configured timeout.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through this transport streamingly.
+
+Sends a tool invocation request to the provider using the appropriate
+protocol and returns the result. Handles serialization of arguments
+and deserialization of responses according to the transport type.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+An async generator that yields the tool's response, with type depending on the tool's output schema.
+
+
+
+**Raises**
+
+- **`ToolNotFoundError`**: If the specified tool doesn't exist.
+- **`ValidationError`**: If the arguments don't match the tool's input schema.
+- **`ConnectionError`**: If unable to communicate with the provider.
+- **`TimeoutError`**: If the tool call exceeds the configured timeout.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/concurrent_tool_repository.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/concurrent_tool_repository.md
new file mode 100644
index 0000000..e58b5da
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/concurrent_tool_repository.md
@@ -0,0 +1,192 @@
+---
+title: concurrent_tool_repository
+sidebar_label: concurrent_tool_repository
+---
+
+# concurrent_tool_repository
+
+**File:** `core/src/utcp/interfaces/concurrent_tool_repository.py`
+
+### class ConcurrentToolRepository {#concurrenttoolrepository}
+
+
+Documentation
+
+Abstract interface for tool and provider storage implementations.
+
+Defines the contract for repositories that manage the lifecycle and storage
+
+**Of Utcp Tools And Call Templates. Repositories Are Responsible For**
+
+- Persisting provider configurations and their associated tools
+- Providing efficient lookup and retrieval operations
+- Managing relationships between call templates and tools
+- Ensuring data consistency during operations
+- Thread safety
+
+The repository interface supports both individual and bulk operations,
+allowing for flexible implementation strategies ranging from simple
+in-memory storage to sophisticated database backends.
+
+
+
+**Note**
+
+All methods are async to support both synchronous and asynchronous
+storage implementations.
+
+
+#### Fields:
+
+- tool_repository_type: str
+
+#### Methods:
+
+
+async save_manual(self, manual_call_template: [CallTemplate](./../data/call_template.md#calltemplate), manual: [UtcpManual](./../data/utcp_manual.md#utcpmanual)) -> None
+
+Save a manual and its tools in the repository.
+
+
+**Args**
+
+- **`manual_call_template`**: The call template associated with the manual to save.
+- **`manual`**: The manual to save.
+
+
+
+async remove_manual(self, manual_name: str) -> bool
+
+Remove a manual and its tools from the repository.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to remove.
+
+
+
+**Returns**
+
+True if the manual was removed, False otherwise.
+
+
+
+async remove_tool(self, tool_name: str) -> bool
+
+Remove a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to remove.
+
+
+
+**Returns**
+
+True if the tool was removed, False otherwise.
+
+
+
+async get_tool(self, tool_name: str) -> Optional[[Tool](./../data/tool.md#tool)]
+
+Get a tool from the repository.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to retrieve.
+
+
+
+**Returns**
+
+The tool if found, otherwise None.
+
+
+
+async get_tools(self) -> List[[Tool](./../data/tool.md#tool)]
+
+Get all tools from the repository.
+
+
+**Returns**
+
+A list of tools.
+
+
+
+async get_tools_by_manual(self, manual_name: str) -> Optional[List[[Tool](./../data/tool.md#tool)]]
+
+Get tools associated with a specific manual.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual.
+
+
+
+**Returns**
+
+A list of tools associated with the manual, or None if the manual is not found.
+
+
+
+async get_manual(self, manual_name: str) -> Optional[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get a manual from the repository.
+
+
+**Args**
+
+- **`manual_name`**: The name of the manual to retrieve.
+
+
+
+**Returns**
+
+The manual if found, otherwise None.
+
+
+
+async get_manuals(self) -> List[[UtcpManual](./../data/utcp_manual.md#utcpmanual)]
+
+Get all manuals from the repository.
+
+
+**Returns**
+
+A list of manuals.
+
+
+
+async get_manual_call_template(self, manual_call_template_name: str) -> Optional[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get a manual call template from the repository.
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the manual call template to retrieve.
+
+
+
+**Returns**
+
+The manual call template if found, otherwise None.
+
+
+
+async get_manual_call_templates(self) -> List[[CallTemplate](./../data/call_template.md#calltemplate)]
+
+Get all manual call templates from the repository.
+
+
+**Returns**
+
+A list of manual call templates.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/serializer.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/serializer.md
new file mode 100644
index 0000000..a7d284f
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/serializer.md
@@ -0,0 +1,79 @@
+---
+title: serializer
+sidebar_label: serializer
+---
+
+# serializer
+
+**File:** `core/src/utcp/interfaces/serializer.py`
+
+### class Serializer (Generic[T]) {#serializer}
+
+
+Documentation
+
+Abstract interface for serializers.
+
+Defines the contract for serializers that convert objects to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting objects to dictionaries for storage or transmission
+- Converting dictionaries back to objects
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Methods:
+
+
+validate_dict(self, obj: dict) -> T
+
+Validate a dictionary and convert it to an object.
+
+
+**Args**
+
+- **`obj`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The object converted from the dictionary.
+
+
+
+to_dict(self, obj: T) -> dict
+
+Convert an object to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The object to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the object.
+
+
+
+copy(self, obj: T) -> T
+
+Create a copy of an object.
+
+
+**Args**
+
+- **`obj`**: The object to copy.
+
+
+
+**Returns**
+
+A copy of the object.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_post_processor.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_post_processor.md
new file mode 100644
index 0000000..68eef6c
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_post_processor.md
@@ -0,0 +1,109 @@
+---
+title: tool_post_processor
+sidebar_label: tool_post_processor
+---
+
+# tool_post_processor
+
+**File:** `core/src/utcp/interfaces/tool_post_processor.py`
+
+### class ToolPostProcessor {#toolpostprocessor}
+
+
+Documentation
+
+Abstract interface for tool post processors.
+
+Defines the contract for tool post processors that process the result of a tool call.
+
+**[Tool](./../data/tool.md#tool) Post Processors Are Responsible For**
+
+- Processing the result of a tool call
+- Returning the processed result
+
+
+#### Fields:
+
+- tool_post_processor_type: str
+
+#### Methods:
+
+
+post_process(self, caller: '[UtcpClient](./../utcp_client.md#utcpclient)', tool: [Tool](./../data/tool.md#tool), manual_call_template: '[CallTemplate](./../data/call_template.md#calltemplate)', result: Any) -> Any
+
+Process the result of a tool call.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool`**: The tool that was called.
+- **`manual_call_template`**: The call template of the manual that was called.
+- **`result`**: The result of the tool call.
+
+
+
+**Returns**
+
+The processed result.
+
+
+---
+
+### class ToolPostProcessorConfigSerializer ([Serializer](./serializer.md#serializer)[ToolPostProcessor]) {#toolpostprocessorconfigserializer}
+
+
+Documentation
+
+[Serializer](./serializer.md#serializer) for tool post processors.
+
+Defines the contract for serializers that convert tool post processors to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tool post processors to dictionaries for storage or transmission
+- Converting dictionaries back to tool post processors
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- tool_post_processor_implementations: Dict[str, [Serializer](./serializer.md#serializer)[ToolPostProcessor]]
+
+#### Methods:
+
+
+to_dict(self, obj: ToolPostProcessor) -> dict
+
+Convert a tool post processor to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The tool post processor to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the tool post processor.
+
+
+
+validate_dict(self, data: dict) -> ToolPostProcessor
+
+Validate a dictionary and convert it to a tool post processor.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The tool post processor converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_search_strategy.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_search_strategy.md
new file mode 100644
index 0000000..68dc8bc
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/tool_search_strategy.md
@@ -0,0 +1,130 @@
+---
+title: tool_search_strategy
+sidebar_label: tool_search_strategy
+---
+
+# tool_search_strategy
+
+**File:** `core/src/utcp/interfaces/tool_search_strategy.py`
+
+### class ToolSearchStrategy {#toolsearchstrategy}
+
+
+Documentation
+
+Abstract interface for tool search implementations.
+
+Defines the contract for tool search strategies that can be plugged into
+the UTCP client. Different implementations can provide various search
+algorithms such as tag-based matching, semantic similarity, or keyword
+search.
+
+
+**Search Strategies Are Responsible For**
+
+- Interpreting search queries
+- Ranking tools by relevance
+- Limiting results appropriately
+- Providing consistent search behavior
+
+
+#### Fields:
+
+- tool_search_strategy_type: str
+
+#### Methods:
+
+
+async search_tools(self, tool_repository: [ConcurrentToolRepository](./concurrent_tool_repository.md#concurrenttoolrepository), query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./../data/tool.md#tool)]
+
+Search for tools relevant to the query.
+
+Executes a search against the available tools and returns the most
+relevant matches ranked by the strategy's scoring algorithm.
+
+
+**Args**
+
+- **`tool_repository`**: The tool repository to search within.
+- **`query`**: The search query string. Format depends on the strategy
+ (e.g., keywords, tags, natural language).
+- **`limit`**: Maximum number of tools to return. Use 0 for no limit.
+ Strategies should respect this limit for performance.
+- **`any_of_tags_required`**: Optional list of tags where one of them must be present in the tool's tags
+ for it to be considered a match.
+
+
+
+**Returns**
+
+List of [Tool](./../data/tool.md#tool) objects ranked by relevance, limited to the
+specified count. Empty list if no matches found.
+
+
+
+**Raises**
+
+- **`ValueError`**: If the query format is invalid for this strategy.
+- **`RuntimeError`**: If the search operation fails unexpectedly.
+
+
+---
+
+### class ToolSearchStrategyConfigSerializer ([Serializer](./serializer.md#serializer)[ToolSearchStrategy]) {#toolsearchstrategyconfigserializer}
+
+
+Documentation
+
+[Serializer](./serializer.md#serializer) for tool search strategies.
+
+Defines the contract for serializers that convert tool search strategies to and from
+
+**Dictionaries For Storage Or Transmission. Serializers Are Responsible For**
+
+- Converting tool search strategies to dictionaries for storage or transmission
+- Converting dictionaries back to tool search strategies
+- Ensuring data consistency during serialization and deserialization
+
+
+#### Fields:
+
+- tool_search_strategy_implementations: Dict[str, [Serializer](./serializer.md#serializer)['ToolSearchStrategy']]
+- `default_strategy`
+
+#### Methods:
+
+
+to_dict(self, obj: ToolSearchStrategy) -> dict
+
+Convert a tool search strategy to a dictionary.
+
+
+**Args**
+
+- **`obj`**: The tool search strategy to convert.
+
+
+
+**Returns**
+
+The dictionary converted from the tool search strategy.
+
+
+
+validate_dict(self, data: dict) -> ToolSearchStrategy
+
+Validate a dictionary and convert it to a tool search strategy.
+
+
+**Args**
+
+- **`data`**: The dictionary to validate and convert.
+
+
+
+**Returns**
+
+The tool search strategy converted from the dictionary.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
new file mode 100644
index 0000000..29568bc
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
@@ -0,0 +1,69 @@
+---
+title: variable_substitutor
+sidebar_label: variable_substitutor
+---
+
+# variable_substitutor
+
+**File:** `core/src/utcp/interfaces/variable_substitutor.py`
+
+### class VariableSubstitutor {#variablesubstitutor}
+
+
+Documentation
+
+Abstract interface for variable substitution implementations.
+
+Defines the contract for variable substitution systems that can replace
+placeholders in configuration data with actual values from various sources.
+Implementations handle different variable resolution strategies and
+source hierarchies.
+
+
+#### Methods:
+
+
+substitute(self, obj: dict | list | str, config: [UtcpClientConfig](./../data/utcp_client_config.md#utcpclientconfig), variable_namespace: Optional[str]) -> Any
+
+Substitute variables in the given object.
+
+
+**Args**
+
+- **`obj`**: Object containing potential variable references to substitute.
+- **`config`**: UTCP client configuration containing variable definitions
+ and loaders.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+Object with all variable references replaced by their values.
+
+
+
+**Raises**
+
+- **`[UtcpVariableNotFound](./../exceptions/utcp_variable_not_found_exception.md#utcpvariablenotfound)`**: If a referenced variable cannot be resolved.
+
+
+
+find_required_variables(self, obj: dict | list | str, variable_namespace: Optional[str]) -> List[str]
+
+Find all variable references in the given object.
+
+
+**Args**
+
+- **`obj`**: Object to scan for variable references.
+- **`variable_namespace`**: Optional variable namespace.
+
+
+
+**Returns**
+
+List of fully-qualified variable names found in the object.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/plugins/discovery.md b/versioned_docs/version-1.0/api/core/utcp/plugins/discovery.md
new file mode 100644
index 0000000..f26ffe2
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/plugins/discovery.md
@@ -0,0 +1,169 @@
+---
+title: discovery
+sidebar_label: discovery
+---
+
+# discovery
+
+**File:** `core/src/utcp/plugins/discovery.py`
+
+### Function register_auth(auth_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[Auth](./../data/auth.md#auth)], override: bool) -> bool {#register_auth}
+
+
+Documentation
+
+Register an authentication implementation.
+
+
+**Args**
+
+- **`auth_type`**: The authentication type identifier.
+- **`serializer`**: The serializer for the authentication implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_variable_loader(loader_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[VariableLoader](./../data/variable_loader.md#variableloader)], override: bool) -> bool {#register_variable_loader}
+
+
+Documentation
+
+Register a variable loader implementation.
+
+
+**Args**
+
+- **`loader_type`**: The variable loader type identifier.
+- **`serializer`**: The serializer for the variable loader implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_call_template(call_template_type: str, serializer: [Serializer](./../interfaces/serializer.md#serializer)[[CallTemplate](./../data/call_template.md#calltemplate)], override: bool) -> bool {#register_call_template}
+
+
+Documentation
+
+Register a call template implementation.
+
+
+**Args**
+
+- **`call_template_type`**: The call template type identifier.
+- **`serializer`**: The serializer for the call template implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_communication_protocol(communication_protocol_type: str, communication_protocol: [CommunicationProtocol](./../interfaces/communication_protocol.md#communicationprotocol), override: bool) -> bool {#register_communication_protocol}
+
+
+Documentation
+
+Register a communication protocol implementation.
+
+
+**Args**
+
+- **`communication_protocol_type`**: The communication protocol type identifier.
+- **`communication_protocol`**: The communication protocol implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_repository(tool_repository_type: str, tool_repository: [Serializer](./../interfaces/serializer.md#serializer)[[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)], override: bool) -> bool {#register_tool_repository}
+
+
+Documentation
+
+Register a tool repository implementation.
+
+
+**Args**
+
+- **`tool_repository_type`**: The tool repository type identifier.
+- **`tool_repository`**: The tool repository implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_search_strategy(strategy_type: str, strategy: [Serializer](./../interfaces/serializer.md#serializer)[[ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)], override: bool) -> bool {#register_tool_search_strategy}
+
+
+Documentation
+
+Register a tool search strategy implementation.
+
+
+**Args**
+
+- **`strategy_type`**: The tool search strategy type identifier.
+- **`strategy`**: The tool search strategy implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
+
+### Function register_tool_post_processor(tool_post_processor_type: str, tool_post_processor: [Serializer](./../interfaces/serializer.md#serializer)[[ToolPostProcessor](./../interfaces/tool_post_processor.md#toolpostprocessor)], override: bool) -> bool {#register_tool_post_processor}
+
+
+Documentation
+
+Register a tool post processor implementation.
+
+
+**Args**
+
+- **`tool_post_processor_type`**: The tool post processor type identifier.
+- **`tool_post_processor`**: The tool post processor implementation.
+- **`override`**: Whether to override an existing implementation.
+
+
+
+**Returns**
+
+True if the implementation was registered, False otherwise.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md b/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
new file mode 100644
index 0000000..17c25ef
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
@@ -0,0 +1,20 @@
+---
+title: plugin_loader
+sidebar_label: plugin_loader
+---
+
+# plugin_loader
+
+**File:** `core/src/utcp/plugins/plugin_loader.py`
+
+### Function ensure_plugins_initialized() {#ensure_plugins_initialized}
+
+
+Documentation
+
+Ensure that plugins are initialized.
+
+This function should be called before using any plugin related functionality is used.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/core/utcp/utcp_client.md b/versioned_docs/version-1.0/api/core/utcp/utcp_client.md
new file mode 100644
index 0000000..63428d9
--- /dev/null
+++ b/versioned_docs/version-1.0/api/core/utcp/utcp_client.md
@@ -0,0 +1,184 @@
+---
+title: utcp_client
+sidebar_label: utcp_client
+---
+
+# utcp_client
+
+**File:** `core/src/utcp/utcp_client.py`
+
+### class UtcpClient {#utcpclient}
+
+
+Documentation
+
+Abstract interface for UTCP client implementations.
+
+Defines the core contract for UTCP clients, including [CallTemplate](./data/call_template.md#calltemplate) management,
+tool execution, search capabilities, and variable handling. This interface
+allows for different client implementations while maintaining consistency.
+
+
+#### Methods:
+
+
+async create(cls, root_dir: Optional[str], config: Optional[Union[str, Dict[str, Any], '[UtcpClientConfig](./data/utcp_client_config.md#utcpclientconfig)']]) -> 'UtcpClient'
+
+Create a new instance of UtcpClient.
+
+
+**Args**
+
+- **`root_dir`**: The root directory for the client to resolve relative paths from. Defaults to the current working directory.
+- **`config`**: The configuration for the client. Can be a path to a configuration file, a dictionary, or [UtcpClientConfig](./data/utcp_client_config.md#utcpclientconfig) object.
+- **`tool_repository`**: The tool repository to use. Defaults to [InMemToolRepository](./implementations/in_mem_tool_repository.md#inmemtoolrepository).
+- **`search_strategy`**: The tool search strategy to use. Defaults to TagSearchStrategy.
+
+
+
+**Returns**
+
+A new instance of UtcpClient.
+
+
+
+async register_manual(self, manual_call_template: [CallTemplate](./data/call_template.md#calltemplate)) -> [RegisterManualResult](./data/register_manual_response.md#registermanualresult)
+
+Register a tool [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The [CallTemplate](./data/call_template.md#calltemplate) to register.
+
+
+
+**Returns**
+
+A [RegisterManualResult](./data/register_manual_response.md#registermanualresult) object containing the registered [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+
+async register_manuals(self, manual_call_templates: List[[CallTemplate](./data/call_template.md#calltemplate)]) -> List[[RegisterManualResult](./data/register_manual_response.md#registermanualresult)]
+
+Register multiple tool CallTemplates and their tools.
+
+
+**Args**
+
+- **`manual_call_templates`**: List of CallTemplates to register.
+
+
+
+**Returns**
+
+A list of [RegisterManualResult](./data/register_manual_response.md#registermanualresult) objects containing the registered CallTemplates and their tools. Order is not preserved.
+
+
+
+async deregister_manual(self, manual_call_template_name: str) -> bool
+
+Deregister a tool [CallTemplate](./data/call_template.md#calltemplate).
+
+
+**Args**
+
+- **`manual_call_template_name`**: The name of the [CallTemplate](./data/call_template.md#calltemplate) to deregister.
+
+
+
+**Returns**
+
+True if the [CallTemplate](./data/call_template.md#calltemplate) was deregistered, False otherwise.
+
+
+
+async call_tool(self, tool_name: str, tool_args: Dict[str, Any]) -> Any
+
+Call a tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: The arguments to pass to the tool.
+
+
+
+**Returns**
+
+The result of the tool call.
+
+
+
+async call_tool_streaming(self, tool_name: str, tool_args: Dict[str, Any]) -> AsyncGenerator[Any, None]
+
+Call a tool streamingly.
+
+
+**Args**
+
+- **`tool_name`**: The name of the tool to call.
+- **`tool_args`**: The arguments to pass to the tool.
+
+
+
+**Returns**
+
+An async generator that yields the result of the tool call.
+
+
+
+async search_tools(self, query: str, limit: int, any_of_tags_required: Optional[List[str]]) -> List[[Tool](./data/tool.md#tool)]
+
+Search for tools relevant to the query.
+
+
+**Args**
+
+- **`query`**: The search query.
+- **`limit`**: The maximum number of tools to return. 0 for no limit.
+- **`any_of_tags_required`**: Optional list of tags where one of them must be present in the tool's tags
+
+
+
+**Returns**
+
+A list of tools that match the search query.
+
+
+
+async get_required_variables_for_manual_and_tools(self, manual_call_template: [CallTemplate](./data/call_template.md#calltemplate)) -> List[str]
+
+Get the required variables for a manual [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+**Args**
+
+- **`manual_call_template`**: The manual [CallTemplate](./data/call_template.md#calltemplate).
+
+
+
+**Returns**
+
+A list of required variables for the manual [CallTemplate](./data/call_template.md#calltemplate) and its tools.
+
+
+
+async get_required_variables_for_registered_tool(self, tool_name: str) -> List[str]
+
+Get the required variables for a registered tool.
+
+
+**Args**
+
+- **`tool_name`**: The name of a registered tool.
+
+
+
+**Returns**
+
+A list of required variables for the tool.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/index.md b/versioned_docs/version-1.0/api/index.md
new file mode 100644
index 0000000..326c91d
--- /dev/null
+++ b/versioned_docs/version-1.0/api/index.md
@@ -0,0 +1,228 @@
+---
+title: UTCP API Reference
+sidebar_label: API Specification
+---
+
+# UTCP API Reference
+
+API specification of a UTCP-compliant client implementation. Any implementation of a UTCP Client needs to have all of the class, functions and fields described in this specification.
+
+This specification is organized by module of the reference python implementation to provide a comprehensive understanding of UTCP's architecture.
+
+**Note:** The modules don't have to be implemented in the same way as in the reference implementation, but all of the functionality here needs to be provided.
+
+**Total documented items:** 189
+**Modules documented:** 39
+
+## Core Modules
+
+Core UTCP framework components that define the fundamental interfaces and implementations.
+
+### [utcp.data.auth](./core\utcp\data\auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.api_key_auth](./core\utcp\data\auth_implementations\api_key_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.basic_auth](./core\utcp\data\auth_implementations\basic_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.auth_implementations.oauth2_auth](./core\utcp\data\auth_implementations\oauth2_auth.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.call_template](./core\utcp\data\call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.register_manual_response](./core\utcp\data\register_manual_response.md)
+
+- **Contains:** 1 classes
+
+
+### [utcp.data.tool](./core\utcp\data\tool.md)
+
+- **Contains:** 4 classes, 4 methods
+
+
+### [utcp.data.utcp_client_config](./core\utcp\data\utcp_client_config.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.utcp_manual](./core\utcp\data\utcp_manual.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [utcp.data.variable_loader](./core\utcp\data\variable_loader.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.data.variable_loader_implementations.dot_env_variable_loader](./core\utcp\data\variable_loader_implementations\dot_env_variable_loader.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.exceptions.utcp_serializer_validation_error](./core\utcp\exceptions\utcp_serializer_validation_error.md)
+
+- **Contains:** 1 classes
+
+
+### [utcp.exceptions.utcp_variable_not_found_exception](./core\utcp\exceptions\utcp_variable_not_found_exception.md)
+
+- **Contains:** 1 classes, 1 methods
+
+
+### [utcp.implementations.default_variable_substitutor](./core\utcp\implementations\default_variable_substitutor.md)
+
+- **Contains:** 1 classes, 2 methods
+
+
+### [utcp.implementations.in_mem_tool_repository](./core\utcp\implementations\in_mem_tool_repository.md)
+
+- **Contains:** 2 classes, 12 methods
+
+
+### [utcp.implementations.tag_search](./core\utcp\implementations\tag_search.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.implementations.utcp_client_implementation](./core\utcp\implementations\utcp_client_implementation.md)
+
+- **Contains:** 1 classes, 9 methods
+
+
+### [utcp.interfaces.communication_protocol](./core\utcp\interfaces\communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [utcp.interfaces.concurrent_tool_repository](./core\utcp\interfaces\concurrent_tool_repository.md)
+
+- **Contains:** 1 classes, 10 methods
+
+
+### [utcp.interfaces.serializer](./core\utcp\interfaces\serializer.md)
+
+- **Contains:** 1 classes, 3 methods
+
+
+### [utcp.interfaces.tool_post_processor](./core\utcp\interfaces\tool_post_processor.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.interfaces.tool_search_strategy](./core\utcp\interfaces\tool_search_strategy.md)
+
+- **Contains:** 2 classes, 3 methods
+
+
+### [utcp.interfaces.variable_substitutor](./core\utcp\interfaces\variable_substitutor.md)
+
+- **Contains:** 1 classes, 2 methods
+
+
+### [utcp.plugins.discovery](./core\utcp\plugins\discovery.md)
+
+- **Contains:** 7 functions
+
+
+### [utcp.plugins.plugin_loader](./core\utcp\plugins\plugin_loader.md)
+
+- **Contains:** 1 functions
+
+
+### [utcp.utcp_client](./core\utcp\utcp_client.md)
+
+- **Contains:** 1 classes, 9 methods
+
+
+## Plugin Modules
+
+Plugin implementations that extend UTCP with specific transport protocols and capabilities.
+
+### [communication_protocols.cli.src.utcp_cli.cli_call_template](./plugins\communication_protocols\cli\src\utcp_cli\cli_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.cli.src.utcp_cli.cli_communication_protocol](./plugins\communication_protocols\cli\src\utcp_cli\cli_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.http_call_template](./plugins\communication_protocols\http\src\utcp_http\http_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.http_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\http_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.openapi_converter](./plugins\communication_protocols\http\src\utcp_http\openapi_converter.md)
+
+- **Contains:** 1 classes, 1 methods
+
+
+### [communication_protocols.http.src.utcp_http.sse_call_template](./plugins\communication_protocols\http\src\utcp_http\sse_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.sse_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\sse_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.http.src.utcp_http.streamable_http_call_template](./plugins\communication_protocols\http\src\utcp_http\streamable_http_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.http.src.utcp_http.streamable_http_communication_protocol](./plugins\communication_protocols\http\src\utcp_http\streamable_http_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+### [communication_protocols.mcp.src.utcp_mcp.mcp_call_template](./plugins\communication_protocols\mcp\src\utcp_mcp\mcp_call_template.md)
+
+- **Contains:** 3 classes, 2 methods
+
+
+### [communication_protocols.mcp.src.utcp_mcp.mcp_communication_protocol](./plugins\communication_protocols\mcp\src\utcp_mcp\mcp_communication_protocol.md)
+
+- **Contains:** 1 classes, 3 methods
+
+
+### [communication_protocols.text.src.utcp_text.text_call_template](./plugins\communication_protocols\text\src\utcp_text\text_call_template.md)
+
+- **Contains:** 2 classes, 2 methods
+
+
+### [communication_protocols.text.src.utcp_text.text_communication_protocol](./plugins\communication_protocols\text\src\utcp_text\text_communication_protocol.md)
+
+- **Contains:** 1 classes, 4 methods
+
+
+## About UTCP
+
+The Universal Tool Calling Protocol (UTCP) is a framework for calling tools across various transport protocols.
+This API reference covers all the essential interfaces, implementations, and extension points needed to:
+
+- **Implement** new transport protocols
+- **Extend** UTCP with custom functionality
+- **Integrate** UTCP into your applications
+- **Understand** the complete UTCP architecture
\ No newline at end of file
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
new file mode 100644
index 0000000..7fd7267
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
@@ -0,0 +1,62 @@
+---
+title: cli_call_template
+sidebar_label: cli_call_template
+---
+
+# cli_call_template
+
+**File:** `plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.py`
+
+### class CliCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#clicalltemplate}
+
+
+Documentation
+
+Call template configuration for Command Line Interface tools.
+
+Enables execution of command-line tools and programs as UTCP providers.
+Supports environment variable injection and custom working directories.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "cli" for CLI providers.
+- **`command_name`**: The name or path of the command to execute.
+- **`env_vars`**: Optional environment variables to set during command execution.
+- **`working_dir`**: Optional custom working directory for command execution.
+- **`auth`**: Always None - CLI providers don't support authentication.
+
+
+#### Fields:
+
+- call_template_type: Literal['cli']
+- command_name: str
+- env_vars: Optional[Dict[str, str]]
+- working_dir: Optional[str]
+- auth: None
+
+---
+
+### class CliCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[CliCallTemplate]) {#clicalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for CliCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: CliCallTemplate) -> dict
+
+Converts a CliCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> CliCallTemplate
+
+Validates a dictionary and returns a CliCallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
new file mode 100644
index 0000000..52ff158
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
@@ -0,0 +1,97 @@
+---
+title: cli_communication_protocol
+sidebar_label: cli_communication_protocol
+---
+
+# cli_communication_protocol
+
+**File:** `plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.py`
+
+### class CliCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#clicommunicationprotocol}
+
+
+Documentation
+
+Transport implementation for CLI-based tool providers.
+
+Handles communication with command-line tools by executing processes
+and managing their input/output. Supports both tool discovery and
+execution phases with comprehensive error handling and timeout management.
+
+
+**Features**
+
+- Asynchronous subprocess execution with proper cleanup
+- [Tool](./../../../../../core/utcp/data/tool.md#tool) discovery through startup commands returning UTCP manuals
+- Flexible argument formatting for various CLI conventions
+- Environment variable injection for authentication
+- JSON output parsing with graceful fallback to text
+- Cross-platform command parsing and execution
+- Configurable working directories and timeouts
+- Process lifecycle management with proper termination
+
+
+
+**Architecture**
+
+CLI tools are discovered by executing the provider's command_name
+and parsing the output for UTCP manual JSON. [Tool](./../../../../../core/utcp/data/tool.md#tool) calls execute
+the same command with formatted arguments and return processed output.
+
+
+
+**Attributes**
+
+- **`_log`**: Logger function for debugging and error reporting.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a CLI manual and discover its tools.
+
+Executes the call template's command_name and looks for a UTCP manual JSON in the output.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a CLI manual (no-op).
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a CLI tool.
+
+Executes the command specified by provider.command_name with the provided arguments.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call
+- **`tool_args`**: Arguments for the tool call
+- **`tool_call_template`**: The [CliCallTemplate](./cli_call_template.md#clicalltemplate) for the tool
+
+
+
+**The Output From The Command Execution Based On Exit Code**
+
+
+
+
+**Raises**
+
+- **`ValueError`**: If provider is not a CliProvider or command_name is not set
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming calls are not supported for CLI protocol.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
new file mode 100644
index 0000000..34f08cc
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
@@ -0,0 +1,71 @@
+---
+title: http_call_template
+sidebar_label: http_call_template
+---
+
+# http_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/http_call_template.py`
+
+### class HttpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#httpcalltemplate}
+
+
+Documentation
+
+Provider configuration for HTTP-based tools.
+
+Supports RESTful HTTP/HTTPS APIs with various HTTP methods, authentication,
+custom headers, and flexible request/response handling. Supports URL path
+parameters using {parameter_name} syntax. All tool arguments not mapped to
+URL body, headers or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "http" for HTTP providers.
+- **`http_method`**: The HTTP method to use for requests.
+- **`url`**: The base URL for the HTTP endpoint. Supports path parameters like
+ "https://api.example.com/users/{user_id}/posts/{post_id}".
+- **`content_type`**: The Content-Type header for requests.
+- **`auth`**: Optional authentication configuration.
+- **`headers`**: Optional static headers to include in all requests.
+- **`body_field`**: Name of the tool argument to map to the HTTP request body.
+- **`header_fields`**: List of tool argument names to map to HTTP request headers.
+
+
+#### Fields:
+
+- call_template_type: Literal['http']
+- http_method: Literal['GET', 'POST', 'PUT', 'DELETE', 'PATCH']
+- url: str
+- content_type: str
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- headers: Optional[Dict[str, str]]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class HttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[HttpCallTemplate]) {#httpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for HttpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: HttpCallTemplate) -> dict
+
+Convert HttpCallTemplate to dictionary.
+
+
+
+validate_dict(self, obj: dict) -> HttpCallTemplate
+
+Validate dictionary and convert to HttpCallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
new file mode 100644
index 0000000..9aa00c5
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
@@ -0,0 +1,108 @@
+---
+title: http_communication_protocol
+sidebar_label: http_communication_protocol
+---
+
+# http_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.py`
+
+### class HttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#httpcommunicationprotocol}
+
+
+Documentation
+
+HTTP communication protocol implementation for UTCP client.
+
+Handles communication with HTTP-based tool providers, supporting various
+authentication methods, URL path parameters, and automatic tool discovery.
+Enforces security by requiring HTTPS or localhost connections.
+
+
+**Features**
+
+- RESTful API communication with configurable HTTP methods
+- URL path parameter substitution from tool arguments
+- [Tool](./../../../../../core/utcp/data/tool.md#tool) discovery from UTCP manuals, OpenAPI specs, and YAML
+- Request body and header field mapping from tool arguments
+- OAuth2 token caching and automatic refresh
+- Security validation of connection URLs
+
+
+
+**Attributes**
+
+- **`_session`**: Optional aiohttp ClientSession for connection reuse.
+- **`_oauth_tokens`**: Cache of OAuth2 tokens by client_id.
+- **`_log`**: Logger function for debugging and error reporting.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`manual_call_template`**: The call template of the manual to register.
+
+
+
+**Returns**
+
+[RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult) object containing the call template and manual.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a manual and its tools.
+
+Deregistering a manual is a no-op for the stateless HTTP communication protocol.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through this transport.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+The tool's response, with type depending on the tool's output schema.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through this transport streamingly.
+
+
+**Args**
+
+- **`caller`**: The UTCP client that is calling this method.
+- **`tool_name`**: Name of the tool to call (may include provider prefix).
+- **`tool_args`**: Dictionary of arguments to pass to the tool.
+- **`tool_call_template`**: Call template of the tool to call.
+
+
+
+**Returns**
+
+An async generator that yields the tool's response.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
new file mode 100644
index 0000000..ae243cc
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
@@ -0,0 +1,60 @@
+---
+title: openapi_converter
+sidebar_label: openapi_converter
+---
+
+# openapi_converter
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/openapi_converter.py`
+
+### class OpenApiConverter {#openapiconverter}
+
+
+Documentation
+
+Converts OpenAPI specifications into UTCP tool definitions.
+
+Processes OpenAPI 2.0 and 3.0 specifications to generate equivalent UTCP
+tools, handling schema resolution, authentication mapping, and proper
+HTTP call_template configuration. Each operation in the OpenAPI spec becomes
+a UTCP tool with appropriate input/output schemas.
+
+
+**Features**
+
+- Complete OpenAPI specification parsing
+- Recursive JSON reference ($ref) resolution
+- Authentication scheme conversion (API key, Basic, OAuth2)
+- Input parameter and request body handling
+- Response schema extraction
+- URL template and path parameter support
+- Provider name normalization
+- Placeholder variable generation for configuration
+
+
+
+**Architecture**
+
+The converter works by iterating through all paths and operations
+in the OpenAPI spec, extracting relevant information for each
+operation, and creating corresponding UTCP tools with HTTP call_templates.
+
+
+
+**Attributes**
+
+- **`spec`**: The parsed OpenAPI specification dictionary.
+- **`spec_url`**: Optional URL where the specification was retrieved from.
+- **`placeholder_counter`**: Counter for generating unique placeholder variables.
+- **`call_template_name`**: Normalized name for the call_template derived from the spec.
+
+
+#### Methods:
+
+
+convert(self) -> [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual)
+
+Parses the OpenAPI specification and returns a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
new file mode 100644
index 0000000..7949c20
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
@@ -0,0 +1,72 @@
+---
+title: sse_call_template
+sidebar_label: sse_call_template
+---
+
+# sse_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/sse_call_template.py`
+
+### class SseCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#ssecalltemplate}
+
+
+Documentation
+
+Provider configuration for Server-Sent Events (SSE) tools.
+
+Enables real-time streaming of events from server to client using the
+Server-Sent Events protocol. Supports automatic reconnection and
+event type filtering. All tool arguments not mapped to URL body, headers
+or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "sse" for SSE providers.
+- **`url`**: The SSE endpoint URL to connect to.
+- **`event_type`**: Optional filter for specific event types. If None, all events are received.
+- **`reconnect`**: Whether to automatically reconnect on connection loss.
+- **`retry_timeout`**: Timeout in milliseconds before attempting reconnection.
+- **`auth`**: Optional authentication configuration.
+- **`headers`**: Optional static headers for the initial connection.
+- **`body_field`**: Optional tool argument name to map to request body during connection.
+- **`header_fields`**: List of tool argument names to map to HTTP headers during connection.
+
+
+#### Fields:
+
+- call_template_type: Literal['sse']
+- url: str
+- event_type: Optional[str]
+- reconnect: bool
+- retry_timeout: int
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- headers: Optional[Dict[str, str]]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class SSECallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[SseCallTemplate]) {#ssecalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for SSECallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: SseCallTemplate) -> dict
+
+Converts a SSECallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> SseCallTemplate
+
+Validates a dictionary and returns a SSECallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
new file mode 100644
index 0000000..3cf186b
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
@@ -0,0 +1,46 @@
+---
+title: sse_communication_protocol
+sidebar_label: sse_communication_protocol
+---
+
+# sse_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.py`
+
+### class SseCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#ssecommunicationprotocol}
+
+
+Documentation
+
+SSE communication protocol implementation for UTCP client.
+
+Handles Server-Sent Events based tool providers with streaming capabilities.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools from an SSE provider.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister an SSE manual and close any active connections.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through SSE transport.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through SSE transport with streaming.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
new file mode 100644
index 0000000..6d2baf4
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
@@ -0,0 +1,74 @@
+---
+title: streamable_http_call_template
+sidebar_label: streamable_http_call_template
+---
+
+# streamable_http_call_template
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.py`
+
+### class StreamableHttpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#streamablehttpcalltemplate}
+
+
+Documentation
+
+Provider configuration for HTTP streaming tools.
+
+Uses HTTP Chunked Transfer Encoding to enable streaming of large responses
+or real-time data. Useful for tools that return large datasets or provide
+progressive results. All tool arguments not mapped to URL body, headers
+or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "streamable_http" for HTTP streaming providers.
+- **`url`**: The streaming HTTP endpoint URL. Supports path parameters.
+- **`http_method`**: The HTTP method to use (GET or POST).
+- **`content_type`**: The Content-Type header for requests.
+- **`chunk_size`**: Size of each chunk in bytes for reading the stream.
+- **`timeout`**: Request timeout in milliseconds.
+- **`headers`**: Optional static headers to include in requests.
+- **`auth`**: Optional authentication configuration.
+- **`body_field`**: Optional tool argument name to map to HTTP request body.
+- **`header_fields`**: List of tool argument names to map to HTTP request headers.
+
+
+#### Fields:
+
+- call_template_type: Literal['streamable_http']
+- url: str
+- http_method: Literal['GET', 'POST']
+- content_type: str
+- chunk_size: int
+- timeout: int
+- headers: Optional[Dict[str, str]]
+- auth: Optional[[Auth](./../../../../../core/utcp/data/auth.md#auth)]
+- body_field: Optional[str]
+- header_fields: Optional[List[str]]
+
+---
+
+### class StreamableHttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[StreamableHttpCallTemplate]) {#streamablehttpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for StreamableHttpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: StreamableHttpCallTemplate) -> dict
+
+Converts a StreamableHttpCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> StreamableHttpCallTemplate
+
+Validates a dictionary and returns a StreamableHttpCallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
new file mode 100644
index 0000000..f79daaf
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
@@ -0,0 +1,46 @@
+---
+title: streamable_http_communication_protocol
+sidebar_label: streamable_http_communication_protocol
+---
+
+# streamable_http_communication_protocol
+
+**File:** `plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.py`
+
+### class StreamableHttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#streamablehttpcommunicationprotocol}
+
+
+Documentation
+
+Streamable HTTP communication protocol implementation for UTCP client.
+
+Handles HTTP streaming with chunked transfer encoding for real-time data.
+
+
+#### Methods:
+
+
+async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual and its tools from a StreamableHttp provider.
+
+
+
+async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a StreamableHttp manual. This is a no-op for the stateless streamable HTTP protocol.
+
+
+
+async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Execute a tool call through StreamableHttp transport.
+
+
+
+async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Execute a tool call through StreamableHttp transport with streaming.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
new file mode 100644
index 0000000..e140b20
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
@@ -0,0 +1,85 @@
+---
+title: mcp_call_template
+sidebar_label: mcp_call_template
+---
+
+# mcp_call_template
+
+**File:** `plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.py`
+
+### class McpConfig {#mcpconfig}
+
+
+Documentation
+
+Implementing this class is not required!!!
+The McpCallTemplate just needs to support a MCP compliant server configuration.
+
+Configuration container for multiple MCP servers.
+
+Holds a collection of named MCP server configurations, allowing
+a single MCP provider to manage multiple server connections.
+
+
+**Attributes**
+
+- **`mcpServers`**: Dictionary mapping server names to their configurations.
+
+
+#### Fields:
+
+- mcpServers: Dict[str, Dict[str, Any]]
+
+---
+
+### class McpCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#mcpcalltemplate}
+
+
+Documentation
+
+Provider configuration for Model Context Protocol (MCP) tools.
+
+Enables communication with MCP servers that provide structured tool
+interfaces. Supports both stdio (local process) and HTTP (remote)
+transport methods.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "mcp" for MCP providers.
+- **`config`**: Configuration object containing MCP server definitions.
+ This follows the same format as the official MCP server configuration.
+- **`auth`**: Optional OAuth2 authentication for HTTP-based MCP servers.
+
+
+#### Fields:
+
+- call_template_type: Literal['mcp']
+- config: McpConfig
+- auth: Optional[[OAuth2Auth](./../../../../../core/utcp/data/auth_implementations/oauth2_auth.md#oauth2auth)]
+
+---
+
+### class McpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[McpCallTemplate]) {#mcpcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for McpCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: McpCallTemplate) -> dict
+
+Convert McpCallTemplate to dictionary.
+
+
+
+validate_dict(self, obj: dict) -> McpCallTemplate
+
+Validate and convert dictionary to McpCallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
new file mode 100644
index 0000000..6f03a6d
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
@@ -0,0 +1,41 @@
+---
+title: mcp_communication_protocol
+sidebar_label: mcp_communication_protocol
+---
+
+# mcp_communication_protocol
+
+**File:** `plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.py`
+
+### class McpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#mcpcommunicationprotocol}
+
+
+Documentation
+
+MCP transport implementation that connects to MCP servers via stdio or HTTP.
+
+This implementation uses a session-per-operation approach where each operation
+(register, call_tool) opens a fresh session, performs the operation, and closes.
+
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a manual with the communication protocol.
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a tool using the model context protocol.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming calls are not supported for MCP protocol, so we just call the tool and return the result as one item.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
new file mode 100644
index 0000000..be893a1
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
@@ -0,0 +1,58 @@
+---
+title: text_call_template
+sidebar_label: text_call_template
+---
+
+# text_call_template
+
+**File:** `plugins/communication_protocols/text/src/utcp_text/text_call_template.py`
+
+### class TextCallTemplate ([CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) {#textcalltemplate}
+
+
+Documentation
+
+Call template for text file-based manuals and tools.
+
+Reads UTCP manuals or tool definitions from local JSON/YAML files. Useful for
+static tool configurations or environments where manuals are distributed as files.
+
+
+**Attributes**
+
+- **`call_template_type`**: Always "text" for text file call templates.
+- **`file_path`**: Path to the file containing the UTCP manual or tool definitions.
+- **`auth`**: Always None - text call templates don't support authentication.
+
+
+#### Fields:
+
+- call_template_type: Literal['text']
+- file_path: str
+- auth: None
+
+---
+
+### class TextCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[TextCallTemplate]) {#textcalltemplateserializer}
+
+
+Documentation
+
+[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for TextCallTemplate.
+
+
+#### Methods:
+
+
+to_dict(self, obj: TextCallTemplate) -> dict
+
+Convert a TextCallTemplate to a dictionary.
+
+
+
+validate_dict(self, obj: dict) -> TextCallTemplate
+
+Validate and convert a dictionary to a TextCallTemplate.
+
+
+---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
new file mode 100644
index 0000000..dc86311
--- /dev/null
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
@@ -0,0 +1,44 @@
+---
+title: text_communication_protocol
+sidebar_label: text_communication_protocol
+---
+
+# text_communication_protocol
+
+**File:** `plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.py`
+
+### class TextCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#textcommunicationprotocol}
+
+
+Documentation
+
+Communication protocol for file-based UTCP manuals and tools.
+
+
+#### Methods:
+
+
+async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
+
+Register a text manual and return its tools as a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+
+
+
+async deregister_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
+
+Deregister a text manual (no-op).
+
+
+
+async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
+
+Call a tool: for text templates, return file content from the configured path.
+
+
+
+async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
+
+Streaming variant: yields the full content as a single chunk.
+
+
+---
diff --git a/versioned_docs/version-1.0/index.md b/versioned_docs/version-1.0/index.md
new file mode 100644
index 0000000..d7f0aae
--- /dev/null
+++ b/versioned_docs/version-1.0/index.md
@@ -0,0 +1,155 @@
+---
+id: index
+title: Introduction
+sidebar_position: 1
+---
+
+# Introduction to UTCP 1.0
+
+The Universal Tool Calling Protocol (UTCP) is a lightweight, secure, and scalable standard for defining and interacting with tools across a wide variety of communication protocols. Version 1.0 introduces a modular core with a plugin-based architecture, making it more extensible, testable, and easier to package.
+
+## Core Components
+
+UTCP consists of four main components:
+
+1. [**Manuals**](./api/core/utcp/data/utcp_manual.md): The standard tool provider description format that contains tool definitions
+2. [**Tools**](./api/core/utcp/data/tool.md): The individual capabilities that can be called
+3. [**Call Templates**](./api/core/utcp/data/call_template.md): The communication configurations that specify how tools are accessed. Concretely this maps a tool name and provided arguments to an actual API request in a communication protocol.
+4. [**UtcpClient**](./api/core/utcp/utcp_client.md): The client that calls tools using the call templates.
+
+## The "Manual" Approach
+
+UTCP's fundamental philosophy is to act as a descriptive manual rather than a prescriptive middleman:
+
+:::note
+A UTCP Manual tells an agent: "Here is a tool. Here is its native endpoint (HTTP, WebSocket, CLI, etc.), and here is how to call it directly."
+:::
+
+This approach eliminates the need for wrapper servers and allows direct communication between agents and tools.
+
+## New Architecture in 1.0
+
+UTCP has been refactored into a core library and a set of optional plugins:
+
+### Core Package (`utcp`)
+- **Data Models**: Pydantic models for [`Tool`](./api/core/utcp/data/tool.md), [`CallTemplate`](./api/core/utcp/data/call_template.md), [`UtcpManual`](./api/core/utcp/data/utcp_manual.md), and [`Auth`](./api/core/utcp/data/auth.md)
+- **Pluggable Interfaces**: [`CommunicationProtocol`](./api/core/utcp/interfaces/communication_protocol.md), [`ConcurrentToolRepository`](./api/core/utcp/interfaces/concurrent_tool_repository.md), [`ToolSearchStrategy`](./api/core/utcp/interfaces/tool_search_strategy.md), [`VariableSubstitutor`](./api/core/utcp/interfaces/variable_substitutor.md), [`ToolPostProcessor`](./api/core/utcp/interfaces/tool_post_processor.md)
+- **Default Implementations**: [`UtcpClient`](./api/core/utcp/utcp_client.md), [`InMemToolRepository`](./api/core/utcp/implementations/in_mem_tool_repository.md), [`TagAndDescriptionWordMatchStrategy`](./api/core/utcp/implementations/tag_search.md)
+
+### Protocol Plugins
+- `utcp-http`: Supports HTTP, SSE, and streamable HTTP, plus an OpenAPI converter
+- `utcp-cli`: For wrapping local command-line tools
+- `utcp-mcp`: For interoperability with the Model Context Protocol (MCP)
+- `utcp-text`: For reading text files
+- `utcp-socket`: TCP and UDP protocols (work in progress)
+- `utcp-gql`: GraphQL (work in progress)
+
+## Minimal Example
+
+Let's see how easy it is to use UTCP with a minimal example.
+
+### 1. Defining a Tool (Tool Provider)
+
+Create a simple HTTP endpoint that serves a UTCP Manual (JSON):
+
+```python
+# app.py
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/utcp")
+def utcp_discovery():
+ return {
+ "manual_version": "1.0.0",
+ "utcp_version": "1.0.1",
+ "tools": [
+ {
+ "name": "get_weather",
+ "description": "Get current weather for a location",
+ "inputs": {
+ "type": "object",
+ "properties": {
+ "location": {
+ "type": "string",
+ "description": "City name"
+ }
+ },
+ "required": ["location"]
+ },
+ "outputs": {
+ "type": "object",
+ "properties": {
+ "temperature": {"type": "number"},
+ "conditions": {"type": "string"}
+ }
+ },
+ "call_template": {
+ "call_template_type": "http",
+ "url": "https://example.com/api/weather",
+ "http_method": "GET"
+ }
+ }
+ ]
+ }
+
+# Implement the actual weather API endpoint
+@app.get("/api/weather")
+def get_weather(location: str):
+ # In a real app, you'd fetch actual weather data
+ return {"temperature": 22.5, "conditions": "Sunny"}
+```
+
+Run the server:
+
+```bash
+uvicorn app:app --reload
+```
+
+### 2. Using the Tool (Client)
+
+```python
+# client.py
+import asyncio
+from utcp.utcp_client import UtcpClient
+from utcp_http.http_call_template import HttpCallTemplate
+
+async def main():
+ # Create a UTCP client with configuration
+ client = await UtcpClient.create(config={
+ "manual_call_templates": [
+ {
+ "name": "weather_service",
+ "call_template_type": "http",
+ "http_method": "GET",
+ "url": "http://localhost:8000/utcp"
+ }
+ ]
+ })
+
+ # Tools are automatically registered from the manual call templates
+ # Call a tool by its namespaced name: {manual_name}.{tool_name}
+ result = await client.call_tool(
+ "weather_service.get_weather",
+ tool_args={"location": "San Francisco"}
+ )
+ print(f"Weather: {result['temperature']}°C, {result['conditions']}")
+
+if __name__ == "__main__":
+ asyncio.run(main())
+```
+
+Run the client:
+
+```bash
+python client.py
+```
+
+## Benefits of the UTCP Approach
+
+1. **Direct Communication**: The client calls the tool's native endpoint directly
+2. **No Wrapper Infrastructure**: No need to build and maintain wrapper servers
+3. **Leverage Existing Systems**: Uses the tool's existing authentication, rate limiting, etc.
+4. **Flexible Protocol Support**: Works with any communication protocol (HTTP, WebSockets, CLI, etc.)
+
+In the following sections, we'll explore the details of UTCP's components and how to implement them in your applications.
diff --git a/versioned_docs/version-1.0/security.md b/versioned_docs/version-1.0/security.md
new file mode 100644
index 0000000..b182938
--- /dev/null
+++ b/versioned_docs/version-1.0/security.md
@@ -0,0 +1,128 @@
+---
+id: security
+title: Security Considerations
+sidebar_position: 6
+---
+
+# Security Considerations
+
+Security is a critical aspect of any protocol that enables tool access and execution. This section outlines key security considerations when implementing and using UTCP.
+
+## Authentication
+
+UTCP supports several authentication methods across different communication protocol types:
+
+### API Key Authentication
+
+```json
+{
+ "auth": {
+ "auth_type": "api_key",
+ "api_key": "YOUR_API_KEY",
+ "var_name": "X-API-Key",
+ "location": "header"
+ }
+}
+```
+
+The `location` field specifies where the API key is placed, and can be `header`, `query`, or `cookie`.
+
+### Basic Authentication
+
+```json
+{
+ "auth": {
+ "auth_type": "basic",
+ "username": "user",
+ "password": "pass"
+ }
+}
+```
+
+### OAuth2 Authentication
+
+```json
+{
+ "auth": {
+ "auth_type": "oauth2",
+ "client_id": "YOUR_CLIENT_ID",
+ "client_secret": "YOUR_CLIENT_SECRET",
+ "token_url": "https://auth.example.com/token",
+ "scope": "read:tools"
+ }
+}
+```
+
+The `scope` field is optional and specifies the level of access that the client is requesting.
+
+## Tool Access Control
+
+When exposing tools through UTCP, consider implementing these access controls:
+
+1. **Tool-Level Permissions**: Define which users/agents can access specific tools
+2. **Parameter Constraints**: Restrict parameter values to prevent abuse
+3. **Rate Limiting**: Implement per-user/per-tool rate limits
+4. **Usage Quotas**: Set maximum usage quotas for tools
+5. **Audit Logging**: Log all tool calls for security monitoring
+
+## Communication Protocol-Specific Considerations
+
+### HTTP
+
+- Always use HTTPS, never HTTP
+
+### CLI
+
+:::important
+
+CLI poses a significant security risk as it executes commands on the local system.
+:::
+
+- Validate and sanitize all input parameters
+- Run commands with the minimum necessary permissions
+- Implement allow-lists for permitted commands
+- Sandbox execution environments when possible
+
+### WebSocket
+
+- Use secure WebSocket (WSS) connections
+
+## Data Protection
+
+1. **Data in Transit**: Ensure all communications use TLS 1.2+ encryption
+2. **Data at Rest**: Encrypt sensitive configuration data
+3. **Sensitive Data in Logs**: Prevent logging of sensitive parameters
+4. **PII Handling**: Implement proper controls for personal information
+
+## Secure Implementation Checklist
+
+- [ ] Use HTTPS/WSS for all network communications
+- [ ] Implement proper authentication for all communication protocols
+- [ ] Validate all input against schemas before processing
+- [ ] Sanitize inputs to prevent injection attacks
+- [ ] Implement rate limiting to prevent abuse
+- [ ] Set appropriate timeouts for all operations
+- [ ] Log security-relevant events
+- [ ] Regularly update dependencies
+- [ ] Implement proper error handling that doesn't leak sensitive information
+
+## Common Vulnerabilities to Avoid
+
+| Vulnerability | Prevention |
+|--------------|------------|
+| Injection Attacks | Validate and sanitize all inputs |
+| Credential Leakage | Use secure credential storage |
+| Excessive Permissions | Follow the principle of least privilege |
+| Man-in-the-Middle | Use certificate validation and pinning |
+| Denial of Service | Implement rate limiting and timeouts |
+| Information Disclosure | Ensure errors don't leak sensitive data |
+
+## Secure Development Lifecycle
+
+1. **Design**: Conduct threat modeling during protocol design
+2. **Implementation**: Follow secure coding practices
+3. **Testing**: Perform security testing and code reviews
+4. **Deployment**: Use secure deployment practices
+5. **Maintenance**: Monitor for security issues and update regularly
+
+By following these security considerations, UTCP implementations can minimize risks while enabling powerful tool integrations across various communication protocols.
diff --git a/versioned_docs/version-1.0/utcp-vs-mcp.md b/versioned_docs/version-1.0/utcp-vs-mcp.md
new file mode 100644
index 0000000..3dec676
--- /dev/null
+++ b/versioned_docs/version-1.0/utcp-vs-mcp.md
@@ -0,0 +1,102 @@
+---
+id: utcp-vs-mcp
+title: UTCP vs MCP
+sidebar_position: 5
+---
+
+# UTCP vs MCP tool calling: A Comparison
+
+This page compares the Universal Tool Calling Protocol (UTCP) with the Model Context Protocol's (MCP) tool calling functionality, highlighting their different approaches to agent-tool integration.
+
+## Video Overview
+
+
+
+## Architectural Differences
+
+| Aspect | MCP | UTCP |
+|--------|-----|------|
+| **Core Model** | Middleman | Manual |
+| **Architecture** | Agents ↔ MCP Server ↔ Tool | Agent ↔ Tool (Direct) |
+| **Integration Approach** | Wraps existing tools | Describes how to call existing tools |
+| **Network Hops** | Double (Agent → MCP → Tool) | Single (Agent → Tool) |
+| **Protocol Dependency** | Hard dependency on protocol for every call | Protocol only needed during discovery |
+
+## The Middleman vs Manual Philosophies
+
+### The MCP "Middleman" Approach
+
+MCP positions itself as the "USB-C for AI Agents" — a universal adapter that all tools must plug into. This approach:
+
+- Forces all traffic through a new protocol layer
+- Requires writing "wrappers" for existing tools
+- Needs to reinvent solutions for auth, security, and other infrastructure concerns
+
+This creates what we call the "wrapper tax": the additional infrastructure, development, and maintenance overhead required to adapt existing tools to work with MCP.
+
+### The UTCP "Manual" Approach
+
+UTCP takes a different approach — it's a "manual" that describes how to call tools directly:
+
+- Provides all necessary information to call native APIs directly
+- Gets out of the way after tool discovery
+- Leverages existing infrastructure for auth, security, etc.
+
+This eliminates the wrapper tax and allows organizations to expose their existing APIs to AI agents without building and maintaining additional infrastructure.
+
+## Feature Comparison
+
+| Feature | MCP | UTCP |
+|---------|-----|------|
+| **Tool Discovery** | Via MCP Server | Via manual discovery endpoint |
+| **Protocol Support** | HTTP Streaming | HTTP, WebSockets, gRPC, CLI, etc. |
+| **Authentication** | Handled by MCP Server | Uses tool's native authentication |
+| **Streaming** | Native support | Supported via appropriate communication protocol (SSE, WebSockets) |
+| **Implementation Complexity** | High (requires wrapper servers) | Low (simple JSON definitions) |
+| **Performance** | Additional overhead due to proxy | Direct, native performance |
+| **Evolution Speed** | Slow (all participants must update) | Fast (individual communication protocols can evolve independently) |
+
+## When to Choose Each Protocol
+
+### Choose MCP When:
+
+- You need strict standardization across all tools
+- You're building a closed ecosystem where you control all components
+- You're willing to invest in building and maintaining wrapper servers
+
+### Choose UTCP When:
+
+- You want to leverage existing APIs without building wrappers
+- You need to support diverse communication protocols
+- You value direct, efficient communication
+- You prioritize low implementation overhead
+- You want to minimize infrastructure costs
+
+## Real-World Example
+
+Consider an organization with an existing REST API that they want to expose to AI agents:
+
+**With MCP:**
+1. Build an MCP server that wraps the REST API
+2. Translate all calls between MCP format and REST format
+3. Maintain and scale this additional server infrastructure
+4. Handle authentication translation between MCP and the API
+
+**With UTCP:**
+1. Create a simple JSON definition describing the REST API
+2. Expose this definition via a discovery endpoint (typically `/utcp`)
+3. The AI agent can now call the REST API directly
+
+## Code comparison
+
+You can find a full typescript example detailing the MCP and UTCP approach [here](https://github.com/universal-tool-calling-protocol/typescript-utcp/tree/main/examples/src/concrete_example).
+
+## Conclusion
+
+Both MCP and UTCP aim to solve the problem of standardizing tool calling for AI agents, but they take fundamentally different approaches.
+
+MCP acts as a middleman, requiring all tools to be wrapped in its protocol. This provides standardization but at the cost of additional infrastructure and development overhead.
+
+UTCP acts as a manual, describing how to call tools directly using their native interfaces. This eliminates the wrapper tax and leverages existing infrastructure, at the cost of requiring clients to handle different communication protocols.
+
+The choice between them depends on your specific requirements, existing infrastructure, and development resources. However, UTCP's "manual" approach offers significant advantages in terms of simplicity, efficiency, and leveraging existing investments in API infrastructure.
diff --git a/versioned_sidebars/version-1.0-sidebars.json b/versioned_sidebars/version-1.0-sidebars.json
new file mode 100644
index 0000000..caea0c0
--- /dev/null
+++ b/versioned_sidebars/version-1.0-sidebars.json
@@ -0,0 +1,8 @@
+{
+ "tutorialSidebar": [
+ {
+ "type": "autogenerated",
+ "dirName": "."
+ }
+ ]
+}
diff --git a/versions.json b/versions.json
index bf528da..bb57766 100644
--- a/versions.json
+++ b/versions.json
@@ -1,3 +1,4 @@
[
+ "1.0",
"0.1"
]
From 453d7dd43601eac6995dbc9d73b55598b2d55489 Mon Sep 17 00:00:00 2001
From: Razvan Radulescu <43811028+h3xxit@users.noreply.github.com>
Date: Tue, 26 Aug 2025 11:18:11 +0200
Subject: [PATCH 2/2] Fix issues
---
.../data/auth_implementations/api_key_auth.md | 8 ++------
.../data/auth_implementations/basic_auth.md | 6 +-----
.../data/auth_implementations/oauth2_auth.md | 6 +-----
docs/api/core/utcp/data/utcp_manual.md | 6 +-----
docs/api/core/utcp/data/variable_loader.md | 6 +-----
.../dot_env_variable_loader.md | 6 +-----
.../utcp_serializer_validation_error.md | 6 +-----
.../default_variable_substitutor.md | 4 ++--
.../implementations/in_mem_tool_repository.md | 18 ++----------------
.../core/utcp/implementations/tag_search.md | 16 ++--------------
.../utcp_client_implementation.md | 8 +-------
.../utcp/interfaces/variable_substitutor.md | 11 +----------
docs/api/core/utcp/plugins/plugin_loader.md | 8 +-------
docs/api/core/utcp/utcp_client.md | 10 +---------
docs/api/index.md | 1 -
.../cli/src/utcp_cli/cli_call_template.md | 10 +++-------
.../src/utcp_cli/cli_communication_protocol.md | 8 +++-----
.../http/src/utcp_http/http_call_template.md | 14 +++++---------
.../utcp_http/http_communication_protocol.md | 4 +---
.../http/src/utcp_http/openapi_converter.md | 2 +-
.../http/src/utcp_http/sse_call_template.md | 12 ++++--------
.../utcp_http/sse_communication_protocol.md | 16 +++++-----------
.../utcp_http/streamable_http_call_template.md | 12 ++++--------
.../streamable_http_communication_protocol.md | 16 +++++-----------
.../mcp/src/utcp_mcp/mcp_call_template.md | 10 +++-------
.../src/utcp_mcp/mcp_communication_protocol.md | 15 ++++-----------
.../text/src/utcp_text/text_call_template.md | 10 +++-------
.../utcp_text/text_communication_protocol.md | 14 +++++---------
.../data/auth_implementations/api_key_auth.md | 8 ++------
.../data/auth_implementations/basic_auth.md | 6 +-----
.../data/auth_implementations/oauth2_auth.md | 6 +-----
.../api/core/utcp/data/utcp_manual.md | 6 +-----
.../api/core/utcp/data/variable_loader.md | 6 +-----
.../dot_env_variable_loader.md | 6 +-----
.../utcp_serializer_validation_error.md | 6 +-----
.../default_variable_substitutor.md | 4 ++--
.../implementations/in_mem_tool_repository.md | 18 ++----------------
.../core/utcp/implementations/tag_search.md | 16 ++--------------
.../utcp_client_implementation.md | 8 +-------
.../utcp/interfaces/variable_substitutor.md | 11 +----------
.../api/core/utcp/plugins/plugin_loader.md | 8 +-------
.../version-1.0/api/core/utcp/utcp_client.md | 10 +---------
versioned_docs/version-1.0/api/index.md | 2 +-
.../cli/src/utcp_cli/cli_call_template.md | 10 +++-------
.../src/utcp_cli/cli_communication_protocol.md | 8 +++-----
.../http/src/utcp_http/http_call_template.md | 14 +++++---------
.../utcp_http/http_communication_protocol.md | 4 +---
.../http/src/utcp_http/openapi_converter.md | 2 +-
.../http/src/utcp_http/sse_call_template.md | 12 ++++--------
.../utcp_http/sse_communication_protocol.md | 16 +++++-----------
.../utcp_http/streamable_http_call_template.md | 12 ++++--------
.../streamable_http_communication_protocol.md | 16 +++++-----------
.../mcp/src/utcp_mcp/mcp_call_template.md | 10 +++-------
.../src/utcp_mcp/mcp_communication_protocol.md | 15 ++++-----------
.../text/src/utcp_text/text_call_template.md | 10 +++-------
.../utcp_text/text_communication_protocol.md | 14 +++++---------
56 files changed, 129 insertions(+), 398 deletions(-)
diff --git a/docs/api/core/utcp/data/auth_implementations/api_key_auth.md b/docs/api/core/utcp/data/auth_implementations/api_key_auth.md
index dedb21e..be07d9c 100644
--- a/docs/api/core/utcp/data/auth_implementations/api_key_auth.md
+++ b/docs/api/core/utcp/data/auth_implementations/api_key_auth.md
@@ -21,7 +21,7 @@ Supports placement in headers, query parameters, or cookies.
**Attributes**
- **`auth_type`**: The authentication type identifier, always "api_key".
-- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '${}' are
+- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '$\{\}' are
treated as an injected variable from environment or configuration.
- **`var_name`**: The name of the header, query parameter, or cookie that
contains the API key.
@@ -39,11 +39,7 @@ Supports placement in headers, query parameters, or cookies.
### class ApiKeyAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[ApiKeyAuth]) {#apikeyauthserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for ApiKeyAuth model.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/data/auth_implementations/basic_auth.md b/docs/api/core/utcp/data/auth_implementations/basic_auth.md
index 87f89ea..ac451d6 100644
--- a/docs/api/core/utcp/data/auth_implementations/basic_auth.md
+++ b/docs/api/core/utcp/data/auth_implementations/basic_auth.md
@@ -35,11 +35,7 @@ encoded in the Authorization header.
### class BasicAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[BasicAuth]) {#basicauthserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for BasicAuth model.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md b/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
index 9fe3024..b6198da 100644
--- a/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
+++ b/docs/api/core/utcp/data/auth_implementations/oauth2_auth.md
@@ -39,11 +39,7 @@ authentication. The client automatically handles token acquisition and refresh.
### class OAuth2AuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[OAuth2Auth]) {#oauth2authserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for OAuth2Auth model.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/data/utcp_manual.md b/docs/api/core/utcp/data/utcp_manual.md
index 10633e2..2bcc886 100644
--- a/docs/api/core/utcp/data/utcp_manual.md
+++ b/docs/api/core/utcp/data/utcp_manual.md
@@ -70,11 +70,7 @@ exclude=["tool1"]
### class UtcpManualSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpManual]) {#utcpmanualserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for UtcpManual model.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/data/variable_loader.md b/docs/api/core/utcp/data/variable_loader.md
index 397eb6b..597cb42 100644
--- a/docs/api/core/utcp/data/variable_loader.md
+++ b/docs/api/core/utcp/data/variable_loader.md
@@ -52,11 +52,7 @@ Variable value if found, None otherwise.
### class VariableLoaderSerializer ([Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]) {#variableloaderserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for VariableLoader model.
-
+*No class documentation available*
#### Fields:
diff --git a/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md b/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
index 7006cd1..1a29499 100644
--- a/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
+++ b/docs/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
@@ -61,11 +61,7 @@ Variable value if found in the file, None otherwise.
### class DotEnvVariableLoaderSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[DotEnvVariableLoader]) {#dotenvvariableloaderserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for DotEnvVariableLoader model.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md b/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
index dd4e59e..4dcaaec 100644
--- a/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
+++ b/docs/api/core/utcp/exceptions/utcp_serializer_validation_error.md
@@ -9,10 +9,6 @@ sidebar_label: utcp_serializer_validation_error
### class UtcpSerializerValidationError {#utcpserializervalidationerror}
-
-Documentation
-
-Exception raised when a serializer validation fails.
-
+*No class documentation available*
---
diff --git a/docs/api/core/utcp/implementations/default_variable_substitutor.md b/docs/api/core/utcp/implementations/default_variable_substitutor.md
index 1300ef6..f10bf69 100644
--- a/docs/api/core/utcp/implementations/default_variable_substitutor.md
+++ b/docs/api/core/utcp/implementations/default_variable_substitutor.md
@@ -49,7 +49,7 @@ Recursively substitute variables in nested data structures.
Performs deep substitution on dictionaries, lists, and strings.
Non-string types are returned unchanged. String values are scanned
-for variable references using ${VAR} and $VAR syntax.
+for variable references using $\{VAR\} and $VAR syntax.
**Args**
@@ -92,7 +92,7 @@ non-string values are preserved.
Recursively discover all variable references in a data structure.
-Scans the object for variable references using ${VAR} and $VAR syntax,
+Scans the object for variable references using $\{VAR\} and $VAR syntax,
returning fully-qualified variable names with variable namespacing.
Useful for validation and dependency analysis.
diff --git a/docs/api/core/utcp/implementations/in_mem_tool_repository.md b/docs/api/core/utcp/implementations/in_mem_tool_repository.md
index b8e39c6..3b774bb 100644
--- a/docs/api/core/utcp/implementations/in_mem_tool_repository.md
+++ b/docs/api/core/utcp/implementations/in_mem_tool_repository.md
@@ -9,15 +9,7 @@ sidebar_label: in_mem_tool_repository
### class InMemToolRepository ([ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)) {#inmemtoolrepository}
-
-Documentation
-
-Thread-safe in-memory implementation of `[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)`.
-
-Stores tools and their associated manual call templates in dictionaries and
-protects all operations with a read-write lock to ensure consistency under
-concurrency while allowing multiple concurrent readers.
-
+*No class documentation available*
#### Methods:
@@ -172,13 +164,7 @@ A list of all manual call templates in the repository.
### class InMemToolRepositoryConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[InMemToolRepository]) {#inmemtoolrepositoryconfigserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for `InMemToolRepository`.
-
-Converts an `InMemToolRepository` instance to a dictionary and vice versa.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/implementations/tag_search.md b/docs/api/core/utcp/implementations/tag_search.md
index 63dcc22..af032ab 100644
--- a/docs/api/core/utcp/implementations/tag_search.md
+++ b/docs/api/core/utcp/implementations/tag_search.md
@@ -9,13 +9,7 @@ sidebar_label: tag_search
### class TagAndDescriptionWordMatchStrategy ([ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)) {#taganddescriptionwordmatchstrategy}
-
-Documentation
-
-Tag and description word match strategy.
-
-This strategy matches tools based on the presence of tags and words in the description.
-
+*No class documentation available*
#### Fields:
@@ -49,13 +43,7 @@ A list of tools that match the query.
### class TagAndDescriptionWordMatchStrategyConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[TagAndDescriptionWordMatchStrategy]) {#taganddescriptionwordmatchstrategyconfigserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for `TagAndDescriptionWordMatchStrategy`.
-
-Converts a `TagAndDescriptionWordMatchStrategy` instance to a dictionary and vice versa.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/implementations/utcp_client_implementation.md b/docs/api/core/utcp/implementations/utcp_client_implementation.md
index b969a77..84430e8 100644
--- a/docs/api/core/utcp/implementations/utcp_client_implementation.md
+++ b/docs/api/core/utcp/implementations/utcp_client_implementation.md
@@ -9,13 +9,7 @@ sidebar_label: utcp_client_implementation
### class UtcpClientImplementation ([UtcpClient](./../utcp_client.md#utcpclient)) {#utcpclientimplementation}
-
-Documentation
-
-Implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
-
-This class provides a concrete implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/interfaces/variable_substitutor.md b/docs/api/core/utcp/interfaces/variable_substitutor.md
index 29568bc..c05966c 100644
--- a/docs/api/core/utcp/interfaces/variable_substitutor.md
+++ b/docs/api/core/utcp/interfaces/variable_substitutor.md
@@ -9,16 +9,7 @@ sidebar_label: variable_substitutor
### class VariableSubstitutor {#variablesubstitutor}
-
-Documentation
-
-Abstract interface for variable substitution implementations.
-
-Defines the contract for variable substitution systems that can replace
-placeholders in configuration data with actual values from various sources.
-Implementations handle different variable resolution strategies and
-source hierarchies.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/core/utcp/plugins/plugin_loader.md b/docs/api/core/utcp/plugins/plugin_loader.md
index 17c25ef..8e8e9c1 100644
--- a/docs/api/core/utcp/plugins/plugin_loader.md
+++ b/docs/api/core/utcp/plugins/plugin_loader.md
@@ -9,12 +9,6 @@ sidebar_label: plugin_loader
### Function ensure_plugins_initialized() {#ensure_plugins_initialized}
-
-Documentation
-
-Ensure that plugins are initialized.
-
-This function should be called before using any plugin related functionality is used.
-
+*No function documentation available*
---
diff --git a/docs/api/core/utcp/utcp_client.md b/docs/api/core/utcp/utcp_client.md
index 63428d9..699279b 100644
--- a/docs/api/core/utcp/utcp_client.md
+++ b/docs/api/core/utcp/utcp_client.md
@@ -9,15 +9,7 @@ sidebar_label: utcp_client
### class UtcpClient {#utcpclient}
-
-Documentation
-
-Abstract interface for UTCP client implementations.
-
-Defines the core contract for UTCP clients, including [CallTemplate](./data/call_template.md#calltemplate) management,
-tool execution, search capabilities, and variable handling. This interface
-allows for different client implementations while maintaining consistency.
-
+*No class documentation available*
#### Methods:
diff --git a/docs/api/index.md b/docs/api/index.md
index ab895d5..51585f8 100644
--- a/docs/api/index.md
+++ b/docs/api/index.md
@@ -1,7 +1,6 @@
---
title: UTCP API Reference
sidebar_label: API Specification
-sidebar_position: 2
---
# UTCP API Reference
diff --git a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
index 7fd7267..abfe4aa 100644
--- a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
+++ b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
@@ -39,24 +39,20 @@ Supports environment variable injection and custom working directories.
### class CliCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[CliCallTemplate]) {#clicalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for CliCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: CliCallTemplate) -> dict
-Converts a CliCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> CliCallTemplate
-Validates a dictionary and returns a CliCallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
index 52ff158..ee2e071 100644
--- a/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
@@ -50,15 +50,13 @@ the same command with formatted arguments and return processed output.
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a CLI manual and discover its tools.
-
-Executes the call template's command_name and looks for a UTCP manual JSON in the output.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a CLI manual (no-op).
+*No method documentation available*
@@ -91,7 +89,7 @@ Executes the command specified by provider.command_name with the provided argume
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming calls are not supported for CLI protocol.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
index 34f08cc..2420d59 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
@@ -16,8 +16,8 @@ Provider configuration for HTTP-based tools.
Supports RESTful HTTP/HTTPS APIs with various HTTP methods, authentication,
custom headers, and flexible request/response handling. Supports URL path
-parameters using {parameter_name} syntax. All tool arguments not mapped to
-URL body, headers or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+parameters using \{parameter_name\} syntax. All tool arguments not mapped to
+URL body, headers or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -48,24 +48,20 @@ URL body, headers or query pattern parameters are passed as query parameters usi
### class HttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[HttpCallTemplate]) {#httpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for HttpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: HttpCallTemplate) -> dict
-Convert HttpCallTemplate to dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> HttpCallTemplate
-Validate dictionary and convert to HttpCallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
index 9aa00c5..a4fa21b 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
@@ -60,9 +60,7 @@ Register a manual and its tools.
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a manual and its tools.
-
-Deregistering a manual is a no-op for the stateless HTTP communication protocol.
+*No method documentation available*
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
index ae243cc..0a68759 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
@@ -54,7 +54,7 @@ operation, and creating corresponding UTCP tools with HTTP call_templates.
convert(self) -> [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual)
-Parses the OpenAPI specification and returns a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
index 7949c20..3dd6951 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
@@ -17,7 +17,7 @@ Provider configuration for Server-Sent Events (SSE) tools.
Enables real-time streaming of events from server to client using the
Server-Sent Events protocol. Supports automatic reconnection and
event type filtering. All tool arguments not mapped to URL body, headers
-or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -49,24 +49,20 @@ or query pattern parameters are passed as query parameters using '?arg_name={arg
### class SSECallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[SseCallTemplate]) {#ssecalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for SSECallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: SseCallTemplate) -> dict
-Converts a SSECallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> SseCallTemplate
-Validates a dictionary and returns a SSECallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
index 3cf186b..c7232b1 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
@@ -9,38 +9,32 @@ sidebar_label: sse_communication_protocol
### class SseCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#ssecommunicationprotocol}
-
-Documentation
-
-SSE communication protocol implementation for UTCP client.
-
-Handles Server-Sent Events based tool providers with streaming capabilities.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual and its tools from an SSE provider.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister an SSE manual and close any active connections.
+*No method documentation available*
async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Execute a tool call through SSE transport.
+*No method documentation available*
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Execute a tool call through SSE transport with streaming.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
index 6d2baf4..45c5817 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
@@ -17,7 +17,7 @@ Provider configuration for HTTP streaming tools.
Uses HTTP Chunked Transfer Encoding to enable streaming of large responses
or real-time data. Useful for tools that return large datasets or provide
progressive results. All tool arguments not mapped to URL body, headers
-or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -51,24 +51,20 @@ or query pattern parameters are passed as query parameters using '?arg_name={arg
### class StreamableHttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[StreamableHttpCallTemplate]) {#streamablehttpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for StreamableHttpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: StreamableHttpCallTemplate) -> dict
-Converts a StreamableHttpCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> StreamableHttpCallTemplate
-Validates a dictionary and returns a StreamableHttpCallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
index f79daaf..ee9052c 100644
--- a/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
@@ -9,38 +9,32 @@ sidebar_label: streamable_http_communication_protocol
### class StreamableHttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#streamablehttpcommunicationprotocol}
-
-Documentation
-
-Streamable HTTP communication protocol implementation for UTCP client.
-
-Handles HTTP streaming with chunked transfer encoding for real-time data.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual and its tools from a StreamableHttp provider.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a StreamableHttp manual. This is a no-op for the stateless streamable HTTP protocol.
+*No method documentation available*
async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Execute a tool call through StreamableHttp transport.
+*No method documentation available*
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Execute a tool call through StreamableHttp transport with streaming.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
index e140b20..2b36fbb 100644
--- a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
+++ b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
@@ -62,24 +62,20 @@ transport methods.
### class McpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[McpCallTemplate]) {#mcpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for McpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: McpCallTemplate) -> dict
-Convert McpCallTemplate to dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> McpCallTemplate
-Validate and convert dictionary to McpCallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
index 6f03a6d..cddd293 100644
--- a/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
@@ -9,33 +9,26 @@ sidebar_label: mcp_communication_protocol
### class McpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#mcpcommunicationprotocol}
-
-Documentation
-
-MCP transport implementation that connects to MCP servers via stdio or HTTP.
-
-This implementation uses a session-per-operation approach where each operation
-(register, call_tool) opens a fresh session, performs the operation, and closes.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual with the communication protocol.
+*No method documentation available*
async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Call a tool using the model context protocol.
+*No method documentation available*
async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming calls are not supported for MCP protocol, so we just call the tool and return the result as one item.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
index be893a1..3c5b062 100644
--- a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
+++ b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
@@ -35,24 +35,20 @@ static tool configurations or environments where manuals are distributed as file
### class TextCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[TextCallTemplate]) {#textcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for TextCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: TextCallTemplate) -> dict
-Convert a TextCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> TextCallTemplate
-Validate and convert a dictionary to a TextCallTemplate.
+*No method documentation available*
---
diff --git a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
index dc86311..9959a8d 100644
--- a/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
+++ b/docs/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
@@ -9,36 +9,32 @@ sidebar_label: text_communication_protocol
### class TextCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#textcommunicationprotocol}
-
-Documentation
-
-Communication protocol for file-based UTCP manuals and tools.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a text manual and return its tools as a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+*No method documentation available*
async deregister_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a text manual (no-op).
+*No method documentation available*
async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Call a tool: for text templates, return file content from the configured path.
+*No method documentation available*
async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming variant: yields the full content as a single chunk.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
index dedb21e..be07d9c 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/api_key_auth.md
@@ -21,7 +21,7 @@ Supports placement in headers, query parameters, or cookies.
**Attributes**
- **`auth_type`**: The authentication type identifier, always "api_key".
-- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '${}' are
+- **`api_key`**: The API key for authentication. Values starting with '$' or formatted as '$\{\}' are
treated as an injected variable from environment or configuration.
- **`var_name`**: The name of the header, query parameter, or cookie that
contains the API key.
@@ -39,11 +39,7 @@ Supports placement in headers, query parameters, or cookies.
### class ApiKeyAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[ApiKeyAuth]) {#apikeyauthserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for ApiKeyAuth model.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
index 87f89ea..ac451d6 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/basic_auth.md
@@ -35,11 +35,7 @@ encoded in the Authorization header.
### class BasicAuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[BasicAuth]) {#basicauthserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for BasicAuth model.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
index 9fe3024..b6198da 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/auth_implementations/oauth2_auth.md
@@ -39,11 +39,7 @@ authentication. The client automatically handles token acquisition and refresh.
### class OAuth2AuthSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[OAuth2Auth]) {#oauth2authserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for OAuth2Auth model.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md b/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
index 10633e2..2bcc886 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/utcp_manual.md
@@ -70,11 +70,7 @@ exclude=["tool1"]
### class UtcpManualSerializer ([Serializer](./../interfaces/serializer.md#serializer)[UtcpManual]) {#utcpmanualserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for UtcpManual model.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
index 397eb6b..597cb42 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader.md
@@ -52,11 +52,7 @@ Variable value if found, None otherwise.
### class VariableLoaderSerializer ([Serializer](./../interfaces/serializer.md#serializer)[VariableLoader]) {#variableloaderserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for VariableLoader model.
-
+*No class documentation available*
#### Fields:
diff --git a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
index 7006cd1..1a29499 100644
--- a/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
+++ b/versioned_docs/version-1.0/api/core/utcp/data/variable_loader_implementations/dot_env_variable_loader.md
@@ -61,11 +61,7 @@ Variable value if found in the file, None otherwise.
### class DotEnvVariableLoaderSerializer ([Serializer](./../../interfaces/serializer.md#serializer)[DotEnvVariableLoader]) {#dotenvvariableloaderserializer}
-
-Documentation
-
-[Serializer](./../../interfaces/serializer.md#serializer) for DotEnvVariableLoader model.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
index dd4e59e..4dcaaec 100644
--- a/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
+++ b/versioned_docs/version-1.0/api/core/utcp/exceptions/utcp_serializer_validation_error.md
@@ -9,10 +9,6 @@ sidebar_label: utcp_serializer_validation_error
### class UtcpSerializerValidationError {#utcpserializervalidationerror}
-
-Documentation
-
-Exception raised when a serializer validation fails.
-
+*No class documentation available*
---
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md b/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
index 1300ef6..f10bf69 100644
--- a/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/default_variable_substitutor.md
@@ -49,7 +49,7 @@ Recursively substitute variables in nested data structures.
Performs deep substitution on dictionaries, lists, and strings.
Non-string types are returned unchanged. String values are scanned
-for variable references using ${VAR} and $VAR syntax.
+for variable references using $\{VAR\} and $VAR syntax.
**Args**
@@ -92,7 +92,7 @@ non-string values are preserved.
Recursively discover all variable references in a data structure.
-Scans the object for variable references using ${VAR} and $VAR syntax,
+Scans the object for variable references using $\{VAR\} and $VAR syntax,
returning fully-qualified variable names with variable namespacing.
Useful for validation and dependency analysis.
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md b/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
index b8e39c6..3b774bb 100644
--- a/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/in_mem_tool_repository.md
@@ -9,15 +9,7 @@ sidebar_label: in_mem_tool_repository
### class InMemToolRepository ([ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)) {#inmemtoolrepository}
-
-Documentation
-
-Thread-safe in-memory implementation of `[ConcurrentToolRepository](./../interfaces/concurrent_tool_repository.md#concurrenttoolrepository)`.
-
-Stores tools and their associated manual call templates in dictionaries and
-protects all operations with a read-write lock to ensure consistency under
-concurrency while allowing multiple concurrent readers.
-
+*No class documentation available*
#### Methods:
@@ -172,13 +164,7 @@ A list of all manual call templates in the repository.
### class InMemToolRepositoryConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[InMemToolRepository]) {#inmemtoolrepositoryconfigserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for `InMemToolRepository`.
-
-Converts an `InMemToolRepository` instance to a dictionary and vice versa.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md b/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
index 63dcc22..af032ab 100644
--- a/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/tag_search.md
@@ -9,13 +9,7 @@ sidebar_label: tag_search
### class TagAndDescriptionWordMatchStrategy ([ToolSearchStrategy](./../interfaces/tool_search_strategy.md#toolsearchstrategy)) {#taganddescriptionwordmatchstrategy}
-
-Documentation
-
-Tag and description word match strategy.
-
-This strategy matches tools based on the presence of tags and words in the description.
-
+*No class documentation available*
#### Fields:
@@ -49,13 +43,7 @@ A list of tools that match the query.
### class TagAndDescriptionWordMatchStrategyConfigSerializer ([Serializer](./../interfaces/serializer.md#serializer)[TagAndDescriptionWordMatchStrategy]) {#taganddescriptionwordmatchstrategyconfigserializer}
-
-Documentation
-
-[Serializer](./../interfaces/serializer.md#serializer) for `TagAndDescriptionWordMatchStrategy`.
-
-Converts a `TagAndDescriptionWordMatchStrategy` instance to a dictionary and vice versa.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md b/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
index b969a77..84430e8 100644
--- a/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
+++ b/versioned_docs/version-1.0/api/core/utcp/implementations/utcp_client_implementation.md
@@ -9,13 +9,7 @@ sidebar_label: utcp_client_implementation
### class UtcpClientImplementation ([UtcpClient](./../utcp_client.md#utcpclient)) {#utcpclientimplementation}
-
-Documentation
-
-Implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
-
-This class provides a concrete implementation of the `[UtcpClient](./../utcp_client.md#utcpclient)` interface.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md b/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
index 29568bc..c05966c 100644
--- a/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
+++ b/versioned_docs/version-1.0/api/core/utcp/interfaces/variable_substitutor.md
@@ -9,16 +9,7 @@ sidebar_label: variable_substitutor
### class VariableSubstitutor {#variablesubstitutor}
-
-Documentation
-
-Abstract interface for variable substitution implementations.
-
-Defines the contract for variable substitution systems that can replace
-placeholders in configuration data with actual values from various sources.
-Implementations handle different variable resolution strategies and
-source hierarchies.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md b/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
index 17c25ef..8e8e9c1 100644
--- a/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
+++ b/versioned_docs/version-1.0/api/core/utcp/plugins/plugin_loader.md
@@ -9,12 +9,6 @@ sidebar_label: plugin_loader
### Function ensure_plugins_initialized() {#ensure_plugins_initialized}
-
-Documentation
-
-Ensure that plugins are initialized.
-
-This function should be called before using any plugin related functionality is used.
-
+*No function documentation available*
---
diff --git a/versioned_docs/version-1.0/api/core/utcp/utcp_client.md b/versioned_docs/version-1.0/api/core/utcp/utcp_client.md
index 63428d9..699279b 100644
--- a/versioned_docs/version-1.0/api/core/utcp/utcp_client.md
+++ b/versioned_docs/version-1.0/api/core/utcp/utcp_client.md
@@ -9,15 +9,7 @@ sidebar_label: utcp_client
### class UtcpClient {#utcpclient}
-
-Documentation
-
-Abstract interface for UTCP client implementations.
-
-Defines the core contract for UTCP clients, including [CallTemplate](./data/call_template.md#calltemplate) management,
-tool execution, search capabilities, and variable handling. This interface
-allows for different client implementations while maintaining consistency.
-
+*No class documentation available*
#### Methods:
diff --git a/versioned_docs/version-1.0/api/index.md b/versioned_docs/version-1.0/api/index.md
index 326c91d..51585f8 100644
--- a/versioned_docs/version-1.0/api/index.md
+++ b/versioned_docs/version-1.0/api/index.md
@@ -5,7 +5,7 @@ sidebar_label: API Specification
# UTCP API Reference
-API specification of a UTCP-compliant client implementation. Any implementation of a UTCP Client needs to have all of the class, functions and fields described in this specification.
+API specification of a UTCP-compliant client implementation. Any implementation of a UTCP Client needs to have all of the classes, functions and fields described in this specification.
This specification is organized by module of the reference python implementation to provide a comprehensive understanding of UTCP's architecture.
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
index 7fd7267..abfe4aa 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_call_template.md
@@ -39,24 +39,20 @@ Supports environment variable injection and custom working directories.
### class CliCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[CliCallTemplate]) {#clicalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for CliCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: CliCallTemplate) -> dict
-Converts a CliCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> CliCallTemplate
-Validates a dictionary and returns a CliCallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
index 52ff158..ee2e071 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/cli/src/utcp_cli/cli_communication_protocol.md
@@ -50,15 +50,13 @@ the same command with formatted arguments and return processed output.
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a CLI manual and discover its tools.
-
-Executes the call template's command_name and looks for a UTCP manual JSON in the output.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a CLI manual (no-op).
+*No method documentation available*
@@ -91,7 +89,7 @@ Executes the command specified by provider.command_name with the provided argume
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming calls are not supported for CLI protocol.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
index 34f08cc..2420d59 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_call_template.md
@@ -16,8 +16,8 @@ Provider configuration for HTTP-based tools.
Supports RESTful HTTP/HTTPS APIs with various HTTP methods, authentication,
custom headers, and flexible request/response handling. Supports URL path
-parameters using {parameter_name} syntax. All tool arguments not mapped to
-URL body, headers or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+parameters using \{parameter_name\} syntax. All tool arguments not mapped to
+URL body, headers or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -48,24 +48,20 @@ URL body, headers or query pattern parameters are passed as query parameters usi
### class HttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[HttpCallTemplate]) {#httpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for HttpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: HttpCallTemplate) -> dict
-Convert HttpCallTemplate to dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> HttpCallTemplate
-Validate dictionary and convert to HttpCallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
index 9aa00c5..a4fa21b 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/http_communication_protocol.md
@@ -60,9 +60,7 @@ Register a manual and its tools.
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a manual and its tools.
-
-Deregistering a manual is a no-op for the stateless HTTP communication protocol.
+*No method documentation available*
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
index ae243cc..0a68759 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/openapi_converter.md
@@ -54,7 +54,7 @@ operation, and creating corresponding UTCP tools with HTTP call_templates.
convert(self) -> [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual)
-Parses the OpenAPI specification and returns a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
index 7949c20..3dd6951 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_call_template.md
@@ -17,7 +17,7 @@ Provider configuration for Server-Sent Events (SSE) tools.
Enables real-time streaming of events from server to client using the
Server-Sent Events protocol. Supports automatic reconnection and
event type filtering. All tool arguments not mapped to URL body, headers
-or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -49,24 +49,20 @@ or query pattern parameters are passed as query parameters using '?arg_name={arg
### class SSECallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[SseCallTemplate]) {#ssecalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for SSECallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: SseCallTemplate) -> dict
-Converts a SSECallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> SseCallTemplate
-Validates a dictionary and returns a SSECallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
index 3cf186b..c7232b1 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/sse_communication_protocol.md
@@ -9,38 +9,32 @@ sidebar_label: sse_communication_protocol
### class SseCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#ssecommunicationprotocol}
-
-Documentation
-
-SSE communication protocol implementation for UTCP client.
-
-Handles Server-Sent Events based tool providers with streaming capabilities.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual and its tools from an SSE provider.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister an SSE manual and close any active connections.
+*No method documentation available*
async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Execute a tool call through SSE transport.
+*No method documentation available*
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Execute a tool call through SSE transport with streaming.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
index 6d2baf4..45c5817 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_call_template.md
@@ -17,7 +17,7 @@ Provider configuration for HTTP streaming tools.
Uses HTTP Chunked Transfer Encoding to enable streaming of large responses
or real-time data. Useful for tools that return large datasets or provide
progressive results. All tool arguments not mapped to URL body, headers
-or query pattern parameters are passed as query parameters using '?arg_name={arg_value}'.
+or query pattern parameters are passed as query parameters using '?arg_name=\{arg_value\}'.
**Attributes**
@@ -51,24 +51,20 @@ or query pattern parameters are passed as query parameters using '?arg_name={arg
### class StreamableHttpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[StreamableHttpCallTemplate]) {#streamablehttpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for StreamableHttpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: StreamableHttpCallTemplate) -> dict
-Converts a StreamableHttpCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> StreamableHttpCallTemplate
-Validates a dictionary and returns a StreamableHttpCallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
index f79daaf..ee9052c 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/http/src/utcp_http/streamable_http_communication_protocol.md
@@ -9,38 +9,32 @@ sidebar_label: streamable_http_communication_protocol
### class StreamableHttpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#streamablehttpcommunicationprotocol}
-
-Documentation
-
-Streamable HTTP communication protocol implementation for UTCP client.
-
-Handles HTTP streaming with chunked transfer encoding for real-time data.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual and its tools from a StreamableHttp provider.
+*No method documentation available*
async deregister_manual(self, caller, manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a StreamableHttp manual. This is a no-op for the stateless streamable HTTP protocol.
+*No method documentation available*
async call_tool(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Execute a tool call through StreamableHttp transport.
+*No method documentation available*
async call_tool_streaming(self, caller, tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Execute a tool call through StreamableHttp transport with streaming.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
index e140b20..2b36fbb 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_call_template.md
@@ -62,24 +62,20 @@ transport methods.
### class McpCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[McpCallTemplate]) {#mcpcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for McpCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: McpCallTemplate) -> dict
-Convert McpCallTemplate to dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> McpCallTemplate
-Validate and convert dictionary to McpCallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
index 6f03a6d..cddd293 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/mcp/src/utcp_mcp/mcp_communication_protocol.md
@@ -9,33 +9,26 @@ sidebar_label: mcp_communication_protocol
### class McpCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#mcpcommunicationprotocol}
-
-Documentation
-
-MCP transport implementation that connects to MCP servers via stdio or HTTP.
-
-This implementation uses a session-per-operation approach where each operation
-(register, call_tool) opens a fresh session, performs the operation, and closes.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a manual with the communication protocol.
+*No method documentation available*
async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Call a tool using the model context protocol.
+*No method documentation available*
async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming calls are not supported for MCP protocol, so we just call the tool and return the result as one item.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
index be893a1..3c5b062 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_call_template.md
@@ -35,24 +35,20 @@ static tool configurations or environments where manuals are distributed as file
### class TextCallTemplateSerializer ([Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer)[TextCallTemplate]) {#textcalltemplateserializer}
-
-Documentation
-
-[Serializer](./../../../../../core/utcp/interfaces/serializer.md#serializer) for TextCallTemplate.
-
+*No class documentation available*
#### Methods:
to_dict(self, obj: TextCallTemplate) -> dict
-Convert a TextCallTemplate to a dictionary.
+*No method documentation available*
validate_dict(self, obj: dict) -> TextCallTemplate
-Validate and convert a dictionary to a TextCallTemplate.
+*No method documentation available*
---
diff --git a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
index dc86311..9959a8d 100644
--- a/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
+++ b/versioned_docs/version-1.0/api/plugins/communication_protocols/text/src/utcp_text/text_communication_protocol.md
@@ -9,36 +9,32 @@ sidebar_label: text_communication_protocol
### class TextCommunicationProtocol ([CommunicationProtocol](./../../../../../core/utcp/interfaces/communication_protocol.md#communicationprotocol)) {#textcommunicationprotocol}
-
-Documentation
-
-Communication protocol for file-based UTCP manuals and tools.
-
+*No class documentation available*
#### Methods:
async register_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> [RegisterManualResult](./../../../../../core/utcp/data/register_manual_response.md#registermanualresult)
-Register a text manual and return its tools as a [UtcpManual](./../../../../../core/utcp/data/utcp_manual.md#utcpmanual).
+*No method documentation available*
async deregister_manual(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', manual_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> None
-Deregister a text manual (no-op).
+*No method documentation available*
async call_tool(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> Any
-Call a tool: for text templates, return file content from the configured path.
+*No method documentation available*
async call_tool_streaming(self, caller: '[UtcpClient](./../../../../../core/utcp/utcp_client.md#utcpclient)', tool_name: str, tool_args: Dict[str, Any], tool_call_template: [CallTemplate](./../../../../../core/utcp/data/call_template.md#calltemplate)) -> AsyncGenerator[Any, None]
-Streaming variant: yields the full content as a single chunk.
+*No method documentation available*
---