sokrates-mcp 0.2.0__py3-none-any.whl

sokrates_mcp/main.py

@@ -0,0 +1,332 @@
+# main.py - MCP Server for sokrates library
+
+# This script sets up an MCP server using the FastMCP framework to provide tools for prompt refinement and execution workflows.
+# It includes several tools that can be used to refine prompts, execute them with external LLMs, break down tasks,
+# generate ideas, perform code reviews, and list available models/providers.
+#
+# Main Purpose
+# The primary purpose of this script is to create a robust MCP server that facilitates interaction with large language models
+# through various prompt engineering workflows. It provides APIs for refining prompts, executing them externally,
+# breaking down complex tasks, generating ideas, performing code reviews, and listing available models/providers.
+#
+# Parameters
+# - `refine_prompt`: Refines a given prompt by enriching it with additional context.
+#   - `prompt` (str): The input prompt to be refined.
+#   - `refinement_type` (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+#   - `provider` (str, optional): Name of the provider to use for refinement. Default is 'default'.
+#   - `model` (str, optional): Model name for refinement. Default is 'default'.
+#
+# - `refine_and_execute_external_prompt`: Refines a prompt and executes it with an external LLM.
+#   - `prompt` (str): The input prompt to be refined and executed.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `refinement_model` (str, optional): Model for refinement. Default is 'default'.
+#   - `execution_model` (str, optional): Model for execution. Default is 'default'.
+#   - `refinement_type` (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+#
+# - `handover_prompt`: Hands over a prompt to an external LLM for processing.
+#   - `prompt` (str): The prompt to be executed externally.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `model` (str, optional): Model name for execution. Default is 'default'.
+#   - `temperature` (float, optional): Temperature for the external execution. Default is 0.7.
+#
+# - `breakdown_task`: Breaks down a task into sub-tasks with complexity ratings.
+#   - `task` (str): The full task description to break down.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `model` (str, optional): Model name for processing. Default is 'default'.
+#
+# - `generate_random_ideas`: Generates random ideas on a random topic.
+#   - `idea_count` (int, optional): Number of ideas to generate. Default is 1.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `model` (str, optional): Model name for generation. Default is 'default'.
+#   - `temperature` (float, optional): Temperature for idea generation. Default is 0.7.
+#
+# - `generate_ideas_on_topic`: Generates ideas on a specific topic.
+#   - `topic` (str): The topic to generate ideas for.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `model` (str, optional): Model name for generation. Default is 'default'.
+#   - `idea_count` (int, optional): Number of ideas to generate. Default is 1.
+#   - `temperature` (float, optional): Temperature for idea generation. Default is 0.7.
+#
+# - `generate_code_review`: Generates a code review in markdown format.
+#   - `source_file_paths` (list): List of source file paths to be reviewed.
+#   - `target_directory` (str): Directory to store the resulting review files.
+#   - `provider` (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+#   - `model` (str, optional): Model name for code review generation. Default is 'default'.
+#   - `review_type` (str, optional): Type of review ('style', 'security', 'performance', 'quality'). Default is 'quality'.
+#
+# - `list_available_models_for_provider`: Lists all available large language models for a specific provider.
+#   - `provider_name` (str, optional): Name of the provider to list models for. Default is empty (uses default).
+#
+# - `list_available_providers`: Lists all configured and available API providers.
+#
+# Usage Examples
+# ```python
+# Refine a prompt
+# await refine_prompt("Write a Python function to sort a list", refinement_type="code")
+#
+# # Refine and execute a prompt with an external LLM
+# await refine_and_execute_external_prompt(
+#     "Generate a summary of the following text: ...",
+#     refinement_model="model1",
+#     execution_model="model2"
+# )
+#
+# # Hand over a prompt to an external LLM
+# await handover_prompt("Translate this text to French: ...")
+#
+# # Break down a task into sub-tasks
+# await breakdown_task("Implement user authentication system")
+#
+# # Generate random ideas
+# await generate_random_ideas(idea_count=3)
+#
+# # Generate ideas on a topic
+# await generate_ideas_on_topic("AI in healthcare", idea_count=5)
+#
+# # Generate code review
+# await generate_code_review(
+#     source_file_paths=["/path/to/file1.py", "/path/to/file2.py"],
+#     target_directory="/path/to/reviews"
+# )
+#
+# # List available models for a provider
+# await list_available_models_for_provider("my-provider")
+#
+# # List all available providers
+# await list_available_providers()
+# ```
+#
+
+from typing import Annotated, Optional
+from pydantic import Field
+from .mcp_config import MCPConfig
+from .workflow import Workflow
+from fastmcp import FastMCP, Context
+import logging
+import os
+import argparse
+
+MCP_NAME = "sokrates-mcp"
+VERSION = "0.2.0"
+DEFAULT_PROVIDER_IDENTIFIER = "default"
+DEFAULT_MODEL_IDENTIFIER = "default"
+DEFAULT_REFINEMENT_TYPE = "default"
+DEFAULT_CODE_REVIEW_TYPE = "quality"
+
+config = MCPConfig()
+workflow = Workflow(config)
+
+# Configure logging for better visibility of fastmcp operations
+log_file_path = os.path.expanduser("~/.sokrates-mcp/server.log")
+os.makedirs(os.path.dirname(log_file_path), exist_ok=True)
+logging.basicConfig(level=logging.INFO, filename=log_file_path, filemode='a', format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Initialize the MCP Server
+mcp = FastMCP(
+    name=MCP_NAME,
+    instructions="A MCP server for using sokrates python library's tools: prompt refinement and improvement workflows.",
+    version=VERSION
+)
+
+# -------------------------------------------------------------------------
+
+@mcp.tool(
+    name="refine_prompt",
+    description="Refines a given prompt by enriching the prompt with additional context and improving clarity for further processing by large language models. A prompt received like this can be sent further directly after receiving the response. The refinement_type can be used to improve the results: e.g. for a coding task this should be set to the code type.",
+    tags={"prompt","refinement"}
+)
+async def refine_prompt(prompt: Annotated[str, Field(description="Input prompt that should be refined")],
+    ctx: Context,
+    refinement_type: Annotated[str, Field(description="The type of the refinement. This could be 'code' (for refining coding tasks) or 'default' . The default type is: default", default=DEFAULT_REFINEMENT_TYPE)],
+    provider: Annotated[str, Field(description="The name of the provider to use for the prompt refinement process. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    model: Annotated[str, Field(description="The name of the model that should be used for the prompt refinement process. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    ) -> str:
+    """
+    Refines a given prompt by enriching the input prompt with additional context and improving clarity
+    for further processing by large language models.
+
+    Args:
+        prompt (str): The input prompt to be refined.
+        ctx (Context): The MCP context object.
+        refinement_type (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+        provider (str, optional): Name of the provider to use for refinement. Default is 'default'.
+        model (str, optional): Model name for refinement. Default is 'default'.
+
+    Returns:
+        str: The refined prompt.
+
+    This function delegates the actual refinement work to the workflow.refine_prompt method.
+    """
+    return await workflow.refine_prompt(prompt=prompt, ctx=ctx, provider=provider, model=model, refinement_type=refinement_type)
+
+# -------------------------------------------------------------------------
+
+@mcp.tool(
+    name="refine_and_execute_external_prompt",
+    description="Refines a given prompt by enriching the input prompt with additional context and then executes the prompt with an external llm. It delivers back the exection result of the refined prompt on the external llm. The refinement_type can be used to improve the results: e.g. for a coding task this should be set to the code type.",
+    tags={"prompt","refinement","external_processing"}
+)
+async def refine_and_execute_external_prompt(prompt: Annotated[str, Field(description="Input prompt that should be refined and then processed.")],
+    ctx: Context,
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    refinement_model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the prompt refinement process. The default refinement model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    execution_model: Annotated[str, Field(description="[Optional] The name of the external model that should be used for the execution of the refined prompt. The default execution model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    refinement_type: Annotated[str, Field(description="The type of the refinement. This could be 'code' (for refining coding tasks) or 'default' for any general refinement tasks. The default type is: default", default=DEFAULT_REFINEMENT_TYPE)],
+    ) -> str:
+    """
+    Refines a given prompt and executes it with an external LLM.
+
+    Args:
+        prompt (str): The input prompt to be refined and executed.
+        ctx (Context): The MCP context object.
+        provider (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+        refinement_model (str, optional): Model for refinement. Default is 'default'.
+        execution_model (str, optional): Model for execution. Default is 'default'.
+        refinement_type (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+
+    Returns:
+        str: The execution result of the refined prompt from the external LLM.
+
+    This function first refines the prompt and then executes it with an external LLM.
+    """
+    return await workflow.refine_and_execute_external_prompt(prompt=prompt, ctx=ctx, provider=provider, refinement_model=refinement_model, execution_model=execution_model, refinement_type=refinement_type)
+
+# -------------------------------------------------------------------------
+
+@mcp.tool(
+    name="handover_prompt",
+    description="Hands over a prompt to an external llm for processing and delivers back the processed result.",
+    tags={"prompt","refinement"}
+)
+async def handover_prompt(prompt: Annotated[str, Field(description="Prompt that should be executed externally.")],
+    ctx: Context,
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    temperature: Annotated[float, Field(description="[Optional] The temperature of the llm to use for generating the ideas. The default value is 0.7 .", default=0.7)],
+    model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the external prompt processing. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    ) -> str:
+    """
+    Hands over a prompt to an external LLM for processing.
+
+    Args:
+        prompt (str): The prompt to be executed externally.
+        ctx (Context): The MCP context object.
+        provider (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+        model (str, optional): Model name for execution. Default is 'default'.
+        temperature (float, optional): Temperature to use for the external execution. Default is 0.7.
+
+    Returns:
+        str: The processed result from the external LLM.
+
+    This function delegates the prompt execution to an external LLM and returns the result.
+    """
+    return await workflow.handover_prompt(prompt=prompt, ctx=ctx, provider=provider, model=model)
+
+# -------------------------------------------------------------------------
+
+@mcp.tool(
+    name="breakdown_task",
+    description="Breaks down a task into sub-tasks back a json list of sub-tasks with complexity ratings.",
+    tags={"prompt","task","breakdown"}
+)
+async def breakdown_task(task: Annotated[str, Field(description="The full task description to break down further.")],
+    ctx: Context,
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the external prompt processing. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    ) -> str:
+    """
+    Breaks down a task into sub-tasks and returns a JSON list of sub-tasks with complexity ratings.
+
+    Args:
+        task (str): The full task description to break down.
+        ctx (Context): The MCP context object.
+        provider (str, optional): Name of the provider to use for LLM interactions. Default is 'default'.
+        model (str, optional): Model name for processing. Default is 'default'.
+
+    Returns:
+        str: A JSON string containing the list of sub-tasks with complexity ratings.
+
+    This function uses an LLM to analyze the task and break it down into manageable sub-tasks.
+    """
+    return await workflow.breakdown_task(task=task, ctx=ctx, provider=provider, model=model)
+
+@mcp.tool(
+    name="generate_random_ideas",
+    description="Invents and generates a random topic an generates the provided count of ideas on the topic.",
+    tags={"idea", "generator","invention","random"}
+)
+async def generate_random_ideas(ctx: Context,
+    idea_count: Annotated[int, Field(description="[Optional] The number of ideas to generate. The default value is 1.", default=1)],
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the generation. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    temperature: Annotated[float, Field(description="[Optional] The temperature of the llm to use for generating the ideas. The default value is 0.7 .", default=0.7)]
+    ) -> str:
+    return await workflow.generate_random_ideas(ctx=ctx, provider=provider, model=model, idea_count=idea_count, temperature=temperature)
+
+@mcp.tool(
+    name="generate_ideas_on_topic",
+    description="Generates the provided count of ideas on the provided topic.",
+    tags={"idea","generator", "idea generation", "invention"}
+)
+async def generate_ideas_on_topic(
+    ctx: Context,
+    topic: Annotated[str, Field(description="The topic to generate ideas for.")],
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the generation. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    idea_count: Annotated[int, Field(description="[Optional] The number of ideas to generate. The default value is 1.", default=1)],
+    temperature: Annotated[float, Field(description="The temperature of the llm to use for generating the ideas. The default value is 0.7 .", default=0.7)]
+    ) -> str:
+    return await workflow.generate_ideas_on_topic(ctx=ctx, provider=provider, model=model, topic=topic, idea_count=idea_count, temperature=temperature)
+
+@mcp.tool(
+    name="generate_code_review",
+    description="Generates a code review in markdown format in a file on the local file system and returns the path to the code review. It supports multiple types of code reviews.",
+    tags={"coding","review","markdown","file"}
+)
+async def generate_code_review(
+    ctx: Context,
+    source_directory: Annotated[str, Field(description="The absolute directory path containing source files to create reviews for. This should contain source files on the local filesystem.")],
+    source_file_paths: Annotated[list, Field(description="A list of absolute source file paths that should be reviewed. The paths should be absolute paths in the local filesystem.")],
+    target_directory: Annotated[str, Field(description="The directory to store the resulting review markdown files. This should point to the desired target path for the markdown files on the local filesystem.")],
+    provider: Annotated[str, Field(description="The name of the provider to use for LLM interactions. The default model name is 'default', which will pick the server's default provider configured.", default=DEFAULT_PROVIDER_IDENTIFIER)],
+    model: Annotated[str, Field(description="[Optional] The name of the model that should be used for the generation. The default model name is 'default', which will pick the server's default model.", default=DEFAULT_MODEL_IDENTIFIER)],
+    review_type: Annotated[str, Field(description="[Optional] The type of review to execute. Choices are: 'style', 'security', 'performance', 'quality' . The default is 'quality'", default=DEFAULT_CODE_REVIEW_TYPE)]
+    ) -> str:
+    return await workflow.generate_code_review(ctx=ctx, provider=provider, model=model, review_type=review_type, source_directory=source_directory, source_file_paths=source_file_paths, target_directory=target_directory)
+
+@mcp.tool(
+    name="list_available_models_for_provider",
+    description="Lists all available large language models and the target api endpoint configured as provider for the sokrates-mcp server.",
+    tags={"external","llm","models","list"}
+)
+async def list_available_models_for_provider(ctx: Context, provider_name: Annotated[str, Field(description="The provider name to list the available models for", default="")]) -> str:
+    return await workflow.list_available_models_for_provider(ctx=ctx, provider_name=provider_name)
+
+@mcp.tool(
+    name="list_available_providers",
+    description="Lists all configured and available API providers for large language models for the sokrates-mcp server.",
+    tags={"external","llm","providers","list"}
+)
+async def list_available_providers(ctx: Context):
+    return await workflow.list_available_providers(ctx=ctx)
+
+def main():
+    # Set up argument parsing
+    parser = argparse.ArgumentParser(description='Sokrates MCP Server')
+    parser.add_argument('--transport', choices=['stdio', 'sse', 'http'], default='stdio',
+                       help='Transport method (default: stdio)')
+    parser.add_argument('--host', type=str, default="127.0.0.1",
+                       help='host for HTTP and sse transport (default: 127.0.0.1)')
+    parser.add_argument('--port', type=int, default=8000,
+                       help='Port number for HTTP transport (default: 8000)')
+    
+    args = parser.parse_args()
+    
+    # Run the MCP server with specified transport and port
+    if args.transport == 'stdio':
+        mcp.run(transport=args.transport)
+    else:
+        mcp.run(transport=args.transport, port=args.port, host=args.host)
+
+if __name__ == "__main__":
+    main()

sokrates_mcp/mcp_config.py

@@ -0,0 +1,236 @@
+# MCP Configuration Module
+#
+# This module provides configuration management for the MCP server.
+# It loads configuration from a YAML file and sets default values if needed.
+#
+# Parameters:
+# - config_file_path: Path to the YAML configuration file (default: ~/.sokrates-mcp/config.yml)
+# - api_endpoint: API endpoint URL (default: http://localhost:1234/v1)
+# - api_key: API key for authentication (default: mykey)
+# - model: Model name to use (default: qwen/qwen3-4b-2507)
+# - verbose: Enable verbose logging (default: False)
+#
+# Usage example:
+#   config = MCPConfig(api_endpoint="https://api.example.com", model="my-model")
+import os
+import yaml
+import logging
+from urllib.parse import urlparse
+from pathlib import Path
+from sokrates import Config
+
+DEFAULT_API_ENDPOINT = "http://localhost:1234/v1"
+DEFAULT_API_KEY = "mykey"
+DEFAULT_MODEL = "qwen/qwen3-4b-2507"
+DEFAULT_PROVIDER_NAME = "default"
+DEFAULT_PROVIDER_TYPE = "openai"
+DEFAULT_PROVIDER_CONFIGURATION = {
+                    "name": DEFAULT_PROVIDER_NAME,
+                    "type": DEFAULT_PROVIDER_TYPE,
+                    "api_endpoint": DEFAULT_API_ENDPOINT,
+                    "api_key": DEFAULT_API_KEY,
+                    "default_model": DEFAULT_MODEL
+                }
+
+class MCPConfig:
+    """Configuration management class for MCP server.
+
+    This class handles loading configuration from a YAML file and provides
+    default values for various parameters.
+
+    Attributes:
+        CONFIG_FILE_PATH (str): Default path to the configuration file
+        DEFAULT_PROMPTS_DIRECTORY (str): Default directory for prompts
+        DEFAULT_REFINEMENT_PROMPT_FILENAME (str): Default refinement prompt filename
+        DEFAULT_REFINEMENT_CODING_PROMPT_FILENAME (str): Default refinement coding prompt filename
+        PROVIDER_TYPES (list): List of supported provider types
+    """
+    CONFIG_FILE_PATH = os.path.expanduser("~/.sokrates-mcp/config.yml")
+    DEFAULT_PROMPTS_DIRECTORY = Config().prompts_directory
+    DEFAULT_REFINEMENT_PROMPT_FILENAME = "refine-prompt.md"
+    DEFAULT_REFINEMENT_CODING_PROMPT_FILENAME = "refine-coding-v3.md"
+    PROVIDER_TYPES = [
+        "openai"
+    ]
+    
+    def __init__(self, config_file_path=CONFIG_FILE_PATH, api_endpoint = DEFAULT_API_ENDPOINT, api_key = DEFAULT_API_KEY, model= DEFAULT_MODEL, verbose=False):
+        """Initialize MCP configuration.
+
+        Args:
+            config_file_path (str): Path to the YAML configuration file.
+                                   Defaults to CONFIG_FILE_PATH.
+            api_endpoint (str): API endpoint URL. Defaults to DEFAULT_API_ENDPOINT.
+            api_key (str): API key for authentication. Defaults to DEFAULT_API_KEY.
+            model (str): Model name to use. Defaults to DEFAULT_MODEL.
+            verbose (bool): Enable verbose logging. Defaults to False.
+
+        Returns:
+            None
+
+        Side Effects:
+            Initializes instance attributes with values from config file or defaults
+            Sets up logging based on verbose parameter
+        """
+        self.logger = logging.getLogger(__name__)
+        self.config_file_path = config_file_path
+        config_data = self._load_config_from_file(self.config_file_path)
+
+        prompts_directory = config_data.get("prompts_directory", self.DEFAULT_PROMPTS_DIRECTORY)
+        if not self._ensure_directory_exists(prompts_directory):
+            raise ValueError(f"Invalid prompts directory: {prompts_directory}")
+        self.prompts_directory = prompts_directory
+
+        refinement_prompt_filename = config_data.get("refinement_prompt_filename", self.DEFAULT_REFINEMENT_PROMPT_FILENAME)
+        if not os.path.exists(os.path.join(prompts_directory, refinement_prompt_filename)):
+            raise FileNotFoundError(f"Refinement prompt file not found: {refinement_prompt_filename}")
+        self.refinement_prompt_filename = refinement_prompt_filename
+
+        refinement_coding_prompt_filename = config_data.get("refinement_coding_prompt_filename", self.DEFAULT_REFINEMENT_CODING_PROMPT_FILENAME)
+        if not os.path.exists(os.path.join(prompts_directory, refinement_coding_prompt_filename)):
+            raise FileNotFoundError(f"Refinement coding prompt file not found: {refinement_coding_prompt_filename}")
+        self.refinement_coding_prompt_filename = refinement_coding_prompt_filename
+    
+
+        self._configure_providers(config_data=config_data)
+        self.logger.info(f"Configuration loaded from {self.config_file_path}:")
+        self.logger.info(f"  Prompts Directory: {self.prompts_directory}")
+        self.logger.info(f"  Refinement Prompt Filename: {self.refinement_prompt_filename}")
+        self.logger.info(f"  Refinement Coding Prompt Filename: {self.refinement_coding_prompt_filename}")
+        self.logger.info(f"  Default Provider: {self.default_provider}")
+        for prov in self.providers:
+            self.logger.info(f"Configured provider name: {prov["name"]} , api_endpoint: {prov["api_endpoint"]} , default_model: {prov["default_model"]}")
+
+    def available_providers(self):
+        return list(map(lambda prov: {'name': prov['name'], 'api_endpoint': prov['api_endpoint'], 'type': prov['type']}, self.providers))
+
+    def get_provider_by_name(self, provider_name):
+        providers = list(filter(lambda x: x['name'] == provider_name, self.providers))
+        return providers[0]
+
+    def get_default_provider(self):
+        return self.get_provider_by_name(self.default_provider)
+
+    def _configure_providers(self, config_data):
+        # configure defaults if not config_data could be loaded
+        self.providers = config_data.get("providers", {})
+        if len(self.providers) < 1:
+            self.providers = [
+                DEFAULT_PROVIDER_CONFIGURATION
+            ]
+            self.default_provider = DEFAULT_PROVIDER_NAME
+            return
+        
+        provider_names = []
+        for provider in self.providers:
+            if provider.get("name") in provider_names:
+                raise ValueError("Duplicate provider names in the config providers section")
+            self._validate_provider(provider)
+            provider_names.append(provider['name'])
+
+        if not config_data['default_provider']:
+            raise ValueError(f"No default_provider was configured at the root level of the config file in {self.config_file_path}")
+        self.default_provider = config_data['default_provider']
+
+    def _validate_provider(self, provider):
+        self._validate_provider_name(provider.get("name", ""))
+        self._validate_provider_type(provider.get("type", ""))
+        self._validate_url(provider.get("api_endpoint", ""))
+        self._validate_api_key(provider.get("api_key", ""))
+        self._validate_model_name(provider.get("default_model", ""))
+
+    def _validate_provider_name(self, provider_name):
+        if len(provider_name) < 1:
+            raise ValueError(f"The provider name: {provider_name} is not a valid provider name")
+
+    def _validate_provider_type(self, provider_type):
+        if not provider_type in self.PROVIDER_TYPES:
+            raise ValueError(f"The provider type: {provider_type} is not supported by sokrates-mcp")
+
+    def _validate_url(self, url):
+        """Validate URL format.
+
+        Args:
+            url (str): URL to validate
+
+        Returns:
+            bool: True if valid URL, False otherwise
+        """
+        try:
+            result = urlparse(url)
+            return all([result.scheme in ['http', 'https'], result.netloc])
+        except:
+            raise ValueError(f"The api_endpoint: {url} is not a valid llm API endpoint")
+
+    def _validate_api_key(self, api_key):
+        """Validate API key format.
+
+        Args:
+            api_key (str): API key to validate
+
+        Returns:
+            bool: True if valid API key, False otherwise
+        """
+        if len(api_key) < 1:
+            raise ValueError("The api key is empty")
+
+    def _validate_model_name(self, model):
+        """Validate model name format.
+
+        Args:
+            model (str): Model name to validate
+
+        Returns:
+            bool: True if valid model name, False otherwise
+        """
+        if len(model) < 1:
+            raise ValueError("The model is empty")
+
+    def _ensure_directory_exists(self, directory_path):
+        """Ensure directory exists and is valid.
+
+        Args:
+            directory_path (str): Directory path to check/validate
+
+        Returns:
+            bool: True if directory exists or was created successfully, False otherwise
+        """
+        try:
+            path = Path(directory_path)
+            if not path.exists():
+                path.mkdir(parents=True, exist_ok=True)
+            return path.is_dir()
+        except Exception as e:
+            self.logger.error(f"Error ensuring directory exists: {e}")
+            return False
+
+    def _load_config_from_file(self, config_file_path):
+        """Load configuration data from a YAML file.
+
+        Args:
+            config_file_path (str): Path to the YAML configuration file
+
+        Returns:
+            dict: Parsed configuration data or empty dict if file doesn't exist
+                  or cannot be parsed
+
+        Side Effects:
+            Logs error messages if file reading or parsing fails
+        """
+        try:
+            # Ensure config directory exists
+            Path(config_file_path).parent.mkdir(parents=True, exist_ok=True)
+
+            if os.path.exists(config_file_path):
+                with open(config_file_path, 'r') as f:
+                    return yaml.safe_load(f) or {}
+            else:
+                self.logger.warning(f"Config file not found at {config_file_path}. Using defaults.")
+                # Create empty config file
+                with open(config_file_path, 'w') as f:
+                    yaml.dump({}, f)
+                return {}
+        except yaml.YAMLError as e:
+            self.logger.error(f"Error parsing YAML config file {config_file_path}: {e}")
+        except Exception as e:
+            self.logger.error(f"Error reading config file {config_file_path}: {e}")
+        return {}

sokrates_mcp/workflow.py

@@ -0,0 +1,293 @@
+from fastmcp import Context
+from .mcp_config import MCPConfig
+from sokrates import FileHelper, RefinementWorkflow, LLMApi, PromptRefiner, IdeaGenerationWorkflow
+from sokrates.coding.code_review_workflow import run_code_review
+from pathlib import Path
+from typing import List
+class Workflow:
+  
+  WORKFLOW_COMPLETION_MESSAGE = "Workflow completed."
+  
+  def __init__(self, config: MCPConfig):
+    """Initialize the workflow with configuration.
+    
+    Args:
+        config (MCPConfig): The MCP configuration object
+    """
+    self.config = config
+    default_provider = self.config.get_default_provider()
+    self.default_model = default_provider['default_model']
+    self.default_api_endpoint = default_provider['api_endpoint']
+    self.default_api_key = default_provider['api_key']
+
+    self.prompt_refiner = PromptRefiner()
+    
+  def _get_model(self, provider, model=''):
+    if not model or model == 'default':
+      return provider['default_model']
+    return model
+  
+  def _get_provider(self, provider_name: str = ''):
+    if not provider_name or provider_name == 'default':
+        provider = self.config.get_default_provider()
+    else:
+        provider = self.config.get_provider_by_name(provider_name)
+    
+    if not provider:
+        raise ValueError(f"Provider '{provider_name}' not found in configuration")
+    return provider
+  
+  def _initialize_refinement_workflow(self, provider_name: str = '', model: str = ''):
+    provider = self._get_provider(provider_name)
+    model = self._get_model(provider=provider, model=model)
+    refinement_workflow = RefinementWorkflow(api_endpoint=provider['api_endpoint'], api_key=provider['api_key'], model=model)
+    return refinement_workflow
+    
+  def load_refinement_prompt(self, refinement_type : str = 'default'):
+    """Load a refinement prompt based on the refinement type.
+    
+    Args:
+        refinement_type (str): Type of refinement ('code' or 'default'). Default is 'default'.
+        
+    Returns:
+        str: The content of the refinement prompt file.
+    """
+    path=self.config.prompts_directory
+    
+    if refinement_type == 'code' or refinement_type == 'coding':
+      refinement_prompt_file = str(Path(f"{path}/{self.config.refinement_coding_prompt_filename}").resolve())
+    else:
+      refinement_prompt_file = str(Path(f"{path}/{self.config.refinement_prompt_filename}").resolve())
+
+    return FileHelper.read_file(refinement_prompt_file, verbose=False)
+    
+  async def refine_prompt(self, prompt: str, ctx: Context, provider: str, model: str, refinement_type: str = 'default') -> str:
+    """Refine a given prompt by enriching it with additional context.
+    
+    Args:
+        prompt (str): The input prompt to be refined.
+        ctx (Context): The MCP context object.
+        provider (str): Name of the provider to use for refinement.
+        model (str): Model name for refinement.
+        refinement_type (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+        
+    Returns:
+        str: The refined prompt.
+    """
+    refinement_prompt = self.load_refinement_prompt(refinement_type)
+    workflow = self._initialize_refinement_workflow(provider_name=provider, model=model)
+    
+    await ctx.info(f"Prompt refinement and execution workflow started with refinement model: {workflow.model} . Waiting for the response from the LLM...")
+    refined = workflow.refine_prompt(input_prompt=prompt, refinement_prompt=refinement_prompt)
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return refined
+  
+  async def refine_and_execute_external_prompt(self, prompt: str, ctx: Context, provider: str, refinement_model: str, execution_model: str, refinement_type: str = 'default') -> str:
+    """Refine a given prompt and execute it with an external LLM.
+    
+    Args:
+        prompt (str): The input prompt to be refined and executed.
+        ctx (Context): The MCP context object.
+        provider (str): Name of the provider to use for LLM interactions.
+        refinement_model (str): Model for refinement.
+        execution_model (str): Model for execution.
+        refinement_type (str, optional): Type of refinement ('code' or 'default'). Default is 'default'.
+        
+    Returns:
+        str: The execution result of the refined prompt from the external LLM.
+    """
+    refinement_prompt = self.load_refinement_prompt(refinement_type)
+
+    prov = self._get_provider(provider)
+    refinement_model = self._get_model(provider=prov, model=refinement_model)
+    execution_model = self._get_model(provider=prov, model=execution_model)
+
+    workflow = self._initialize_refinement_workflow(provider_name=provider, model=execution_model)
+    await ctx.info(f"Prompt refinement and execution workflow started with refinement model: {refinement_model} and execution model {execution_model} . Waiting for the responses from the LLMs...")
+    result = workflow.refine_and_send_prompt(input_prompt=prompt, refinement_prompt=refinement_prompt, refinement_model=refinement_model, execution_model=execution_model)
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result
+  
+  async def handover_prompt(self, prompt: str, ctx: Context, provider: str, model: str, temperature=0.7) -> str:
+    """Hands over a prompt to an external LLM for processing.
+    
+    Args:
+        prompt (str): The prompt to be executed externally.
+        ctx (Context): The MCP context object.
+        provider (str): Name of the provider to use for LLM interactions.
+        model (str): Model name for execution.
+        temperature (float, optional): Temperature to use for the external execution. Default is 0.7.
+        
+    Returns:
+        str: The processed result from the external LLM.
+    """
+    refiner = PromptRefiner()
+    
+    prov = self._get_provider(provider)
+    model = self._get_model(provider=prov, model=model)
+    llm_api = LLMApi(api_endpoint=prov['api_endpoint'], api_key=prov['api_key'])
+
+    result = llm_api.send(prompt,model=model, temperature=temperature)
+    result = refiner.clean_response(result)
+    
+    await ctx.info(f"External Prompt execution workflow started with model: {model} . Waiting for the responses from the LLM...")
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result
+  
+  async def breakdown_task(self, task: str, ctx: Context, provider: str, model: str) -> str:
+    """Breaks down a task into sub-tasks with complexity ratings.
+    
+    Args:
+        task (str): The full task description to break down.
+        ctx (Context): The MCP context object.
+        provider (str): Name of the provider to use for LLM interactions.
+        model (str): Model name for processing.
+        
+    Returns:
+        str: A JSON string containing the list of sub-tasks with complexity ratings.
+    """
+    workflow = self._initialize_refinement_workflow(provider_name=provider, model=model)
+    await ctx.info(f"Task break-down started with model: {workflow.model} . Waiting for the response from the LLM...")
+    result = workflow.breakdown_task(task=task)
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result
+  
+  async def generate_random_ideas(self, ctx: Context, provider: str, idea_count: int = 1, temperature: float = 0.7, model: str = None) -> str:
+    """Generate random ideas on a random topic.
+    
+    Args:
+        ctx (Context): The MCP context object.
+        provider (str): Name of the provider to use for LLM interactions.
+        idea_count (int, optional): Number of ideas to generate. Default is 1.
+        temperature (float, optional): Temperature for idea generation. Default is 0.7.
+        model (str, optional): Model name for generation. Default is 'default'.
+        
+    Returns:
+        str: Generated ideas separated by ---.
+    """
+    prov = self._get_provider(provider)
+    model = self._get_model(provider=prov, model=model)
+    await ctx.info(f"Task `generate random ideas` started at provider: {prov['name']} with model: {model} , idea_count: {idea_count} and temperature: {temperature}. Waiting for the response from the LLM...")
+
+    idea_generation_workflow = IdeaGenerationWorkflow(api_endpoint=prov['api_endpoint'],
+      api_key=prov['api_key'],
+      idea_count=idea_count,
+      temperature=temperature,
+      generator_llm_model=model,
+      refinement_llm_model=model,
+      execution_llm_model=model,
+      topic_generation_llm_model=model
+    )
+    results = idea_generation_workflow.run()
+    result_text = f"\n---\n".join(results)
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result_text
+  
+  async def generate_ideas_on_topic(self, ctx: Context, topic: str, provider: str, model: str, idea_count: int = 1, temperature: float = 0.7) -> str:
+    """Generate ideas on a specific topic.
+    
+    Args:
+        ctx (Context): The MCP context object.
+        topic (str): The topic to generate ideas for.
+        provider (str): Name of the provider to use for LLM interactions.
+        model (str): Model name for generation.
+        idea_count (int, optional): Number of ideas to generate. Default is 1.
+        temperature (float, optional): Temperature for idea generation. Default is 0.7.
+        
+    Returns:
+        str: Generated ideas separated by ---.
+    """
+    prov = self._get_provider(provider)
+    model = self._get_model(provider=prov, model=model)
+
+    await ctx.info(f"Task `generate ideas on topic` started with topic: '{topic}' , model: {model} , idea_count: {idea_count} and temperature: {temperature}. Waiting for the response from the LLM...")
+    idea_generation_workflow = IdeaGenerationWorkflow(api_endpoint=prov['api_endpoint'],
+      api_key=prov['api_key'],
+      topic=topic,
+      idea_count=idea_count,
+      temperature=temperature,
+      generator_llm_model=model,
+      refinement_llm_model=model,
+      execution_llm_model=model,
+      topic_generation_llm_model=model
+    )
+    results = idea_generation_workflow.run()
+    result_text = f"\n---\n".join(results)
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result_text
+  
+  async def generate_code_review(self, ctx: Context, source_directory: str, source_file_paths: List[str], target_directory: str, provider: str, model:str, review_type:str):
+    """Generate a code review in markdown format.
+    
+    Args:
+        ctx (Context): The MCP context object.
+        source_file_paths (list): List of source file paths to be reviewed.
+        target_directory (str): Directory to store the resulting review files.
+        provider (str): Name of the provider to use for LLM interactions.
+        model (str): Model name for code review generation.
+        review_type (str): Type of review ('style', 'security', 'performance', 'quality'). Default is 'quality'.
+        
+    Returns:
+        str: Success message with path to generated files.
+    """
+    prov = self._get_provider(provider)
+    model = self._get_model(provider=prov, model=model)
+
+    await ctx.info(f"Generating code review of type: {review_type} - using model: {model} ...")
+    run_code_review(file_paths=source_file_paths,
+                    directory_path=source_directory,
+                    output_dir=target_directory,
+                    review_type=review_type,
+                    api_endpoint=prov['api_endpoint'],
+                    api_key=prov['api_key'],
+                    model=model)
+    # TODO: also include some basic info of the review results (e.g. the complete review file list)
+    # so that the caller gains more information about the result and file locations
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return f"Successfully generated review files in {target_directory} ."
+    
+    
+  async def list_available_providers(self, ctx: Context) -> str:
+    """List all configured and available API providers.
+    
+    Args:
+        ctx (Context): The MCP context object.
+        
+    Returns:
+        str: Formatted list of configured providers.
+    """
+    providers = self.config.available_providers()
+    result = "# Configured providers"
+    for prov in providers:
+      prov_string = f"-{prov['name']} : type: {prov['type']} - api_endpoint: {prov['api_endpoint']}"
+      result = f"{result}\n{prov_string}"
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result
+
+  async def list_available_models_for_provider(self, ctx: Context, provider_name: str = "") -> str:
+    """List all available large language models for a specific provider.
+    
+    Args:
+        ctx (Context): The MCP context object.
+        provider_name (str, optional): Name of the provider to list models for. Default is empty (uses default).
+        
+    Returns:
+        str: Formatted list of available models and API endpoint.
+    """
+    await ctx.info(f"Retrieving endpoint information and list of available models for configured provider {provider_name} ...")
+    if not provider_name:
+      provider = self.config.get_default_provider()
+    else:
+      provider = self.config.get_provider_by_name(provider_name)
+    
+    llm_api = LLMApi(api_endpoint=provider['api_endpoint'], api_key=provider['api_key'])
+    models = llm_api.list_models()
+    if not models:
+      return "# No models available"
+
+    api_headline = f"# Target API Endpoint\n{provider['api_endpoint']}\n"
+
+    model_list = "\n".join([f"- {model}" for model in models])
+    result = f"{api_headline}\n# List of available models\n{model_list}"
+    await ctx.info(self.WORKFLOW_COMPLETION_MESSAGE)
+    return result

sokrates_mcp-0.2.0.dist-info/METADATA

@@ -0,0 +1,307 @@
+Metadata-Version: 2.4
+Name: sokrates-mcp
+Version: 0.2.0
+Summary: A templated MCP server for demonstration and quick start.
+Author-email: Julian Weber <julianweberdev@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 Julian Weber
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/Kubementat/sokrates-mcp
+Project-URL: Repository, https://github.com/Kubementat/sokrates-mcp
+Keywords: mcp,llm,tools,system-monitoring,ai,prompt refinement,idea generation
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp
+Requires-Dist: sokrates
+Requires-Dist: pydantic
+Requires-Dist: PyYAML
+Dynamic: license-file
+
+# sokrates-mcp
+
+A MCP server offering tools for prompt refinement and execution workflows using the FastMCP framework and the `sokrates` python library.
+
+## Features
+
+- Multiple provider/APU support
+- Available Model/Provider listing
+- Prompt refinement with different types (code/default)
+- External LLM processing
+- Task breakdown into sub-tasks
+- Create code reviews for Python source files
+- Generate random ideas
+- Generate ideas to a topic
+
+Have a look at the [sokrates library](https://github.com/Kubementat/sokrates).
+
+## Installation & Setup
+
+### Prerequisites
+
+Ensure you have:
+* Python 3.10+
+* uv (fast package installer)
+
+### Install from PyPi
+```bash
+pip install sokrates-mcp
+
+# or using uv (recommended)
+## basic version: 
+uv pip install sokrates-mcp
+```
+
+### Alternative - Local Configuration from git
+
+1. Clone the repository if hosted:
+```bash
+git clone https://github.com/Kubementat/sokrates-mcp.git
+cd sokrates-mcp
+```
+
+2. Install dependencies using pyproject.toml:
+```bash
+uv sync
+```
+
+### Setup Server Configuration File
+
+#### Via git installed version
+```bash
+mkdir $HOME/.sokrates-mcp
+cp config.yml.example $HOME/.sokrates-mcp/config.yml
+# edit the according endpoints to your use case
+vim $HOME/.sokrates-mcp/config.yml
+```
+
+#### From scratch
+Create the configuration file:
+```bash
+mkdir $HOME/.sokrates-mcp
+vim $HOME/.sokrates-mcp/config.yml
+```
+
+Then use this as template and adjust it to your use case:
+```yaml
+refinement_prompt_filename: refine-prompt.md
+refinement_coding_prompt_filename: refine-coding-v3.md
+
+# providers
+default_provider: local
+providers:
+  - name: local
+    type: openai
+    api_endpoint: http://localhost:1234/v1
+    api_key: "not-required"
+    default_model: "qwen/qwen3-4b-2507"
+  - name: external
+    type: openai
+    api_endpoint: http://CHANGEME/v1
+    api_key: CHANGEME
+    default_model: CHANGEME
+```
+
+### Setup as mcp server in other tools (Example for LM Studio)
+
+#### For local Git installed version
+```yaml
+{
+  "mcpServers": {
+    "sokrates": {
+      "command": "uv",
+      "args": [
+        "run",
+        "sokrates-mcp"
+      ],
+      "cwd": "YOUR_PATH_TO_sokrates-mcp",
+      "timeout": 600000
+    }
+  }
+}
+```
+
+#### via uvx
+```yaml
+{
+  "mcpServers": {
+    "sokrates": {
+      "command": "uvx",
+      "args": [
+        "sokrates-mcp"
+      ]
+    }
+  }
+}
+```
+
+## Usage Examples
+
+### Starting the Server
+
+```bash
+uv run sokrates-mcp
+```
+
+### Listing available command line options
+```bash
+uv run sokrates-mcp --help
+```
+
+## Architecture & Technical Details
+
+The server follows a modular design pattern:
+1. Tools are registered in `main.py` using FastMCP decorators
+2. Dependency management via pyproject.toml
+3. Configuration files stored in `$HOME/.sokrates-mcp/` directory
+
+
+## Contributing Guidelines
+
+1. Fork the repository and create feature branches
+2. Follow PEP8 style guide with 4-space indentation
+3. Submit pull requests with:
+   - Clear description of changes
+   - Updated tests (see Testing section)
+   - Documentation updates
+
+## Available Tools
+
+### main.py
+
+- **refine_prompt**: Refines a given prompt by enriching it with additional context.
+  - Parameters:
+    - `prompt` (str): The input prompt to be refined
+    - `refinement_type` (str, optional): Type of refinement ('code' or 'default'). Default is 'default'
+    - `model` (str, optional): Model name for refinement. Default is 'default'
+
+- **refine_and_execute_external_prompt**: Refines a prompt and executes it with an external LLM.
+  - Parameters:
+    - `prompt` (str): The input prompt to be refined and executed
+    - `refinement_model` (str, optional): Model for refinement. Default is 'default'
+    - `execution_model` (str, optional): Model for execution. Default is 'default'
+    - `refinement_type` (str, optional): Type of refinement ('code' or 'default'). Default is 'default'
+
+- **handover_prompt**: Hands over a prompt to an external LLM for processing.
+  - Parameters:
+    - `prompt` (str): The prompt to be executed externally
+    - `model` (str, optional): Model name for execution. Default is 'default'
+
+- **breakdown_task**: Breaks down a task into sub-tasks with complexity ratings.
+  - Parameters:
+    - `task` (str): The full task description to break down
+    - `model` (str, optional): Model name for processing. Default is 'default'
+
+- **list_available_models**: Lists all available large language models accessible by the server.
+
+### mcp_config.py
+
+- **MCPConfig** class: Manages configuration settings for the MCP server.
+  - Parameters:
+    - `config_file_path` (str, optional): Path to YAML config file
+    - `api_endpoint` (str, optional): API endpoint URL
+    - `api_key` (str, optional): API key for authentication
+    - `model` (str, optional): Model name
+
+### workflow.py
+
+- **Workflow** class: Implements the business logic for prompt refinement and execution.
+  - Methods:
+    - `refine_prompt`: Refines a given prompt
+    - `refine_and_execute_external_prompt`: Refines and executes a prompt with an external LLM
+    - `handover_prompt`: Hands over a prompt to an external LLM for processing
+    - `breakdown_task`: Breaks down a task into sub-tasks
+    - `list_available_models`: Lists all available models
+
+## Project Structure
+
+- `src/sokrates_mcp/main.py`: Sets up the MCP server and registers tools
+- `src/sokrates_mcp/mcp_config.py`: Configuration management
+- `src/sokrates_mcp/workflow.py`: Business logic for prompt refinement and execution
+- `pyproject.toml`: Dependency management
+
+
+## Script List
+
+### `main.py`
+Sets up an MCP server using the FastMCP framework to provide tools for prompt refinement and execution workflows.
+#### Usage
+- `uv run python main.py` - Start the MCP server (default port: 8000)
+- `uv run fastmcp dev main.py` - Run in development mode with auto-reload
+
+### `mcp_config.py`
+Provides configuration management for the MCP server. Loads configuration from a YAML file and sets default values if needed.
+#### Usage
+- Import and use in other scripts:
+  ```python
+  from mcp_config import MCPConfig
+  config = MCPConfig(api_endpoint="https://api.example.com", model="my-model")
+  ```
+
+### `workflow.py`
+Implements the business logic for prompt refinement and execution workflows. Contains methods to refine prompts, execute them with external LLMs, break down tasks, etc.
+#### Usage
+- Import and use in other scripts:
+  ```python
+  from workflow import Workflow
+  from mcp_config import MCPConfig
+
+  config = MCPConfig()
+  workflow = Workflow(config)
+  result = await workflow.refine_prompt("Write a Python function to sort a list", refinement_type="code")
+  ```
+
+### `src/mcp_client_example.py`
+Demonstrates a basic Model Context Protocol (MCP) client using the fastmcp library. Defines a simple model and registers it with the client.
+
+#### Usage
+- Run as a standalone script:
+  ```bash
+  python src/mcp_client_example.py
+  ```
+- Or use with an ASGI server like Uvicorn:
+  ```bash
+  uvicorn src.mcp_client_example:main --factory
+  ```
+
+**Common Error:**
+If you see "ModuleNotFoundError: fastmcp", ensure:
+1. Dependencies are installed (`uv pip install .`)
+2. Python virtual environment is activated
+
+## Changelog
+
+**0.2.0 (Aug 2025)**
+- First published version
+- Update to latest sokrates library version
+- bugfixes and cleanup
+- multi provider/API support in the configuration file 
+
+**0.1.5 (July 2025)**
+- Updated README with comprehensive documentation
+- Added tool descriptions and usage examples
+- Improved project structure overview
+
+**0.1.0 (March 7, 2025)**
+- Initial release with refinement tools
+- Basic FastMCP integration
+
+Bug reports and feature requests: [GitHub Issues](https://github.com/Kubementat/sokrates-mcp/issues)

sokrates_mcp-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+sokrates_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sokrates_mcp/main.py,sha256=2zIm3lkP3xJyS-_w6oJb-qovdjjCw0D4oocAapgdzVA,20697
+sokrates_mcp/mcp_config.py,sha256=5LA72MwmoM8LpUNx4cUkU4e5Xif6nhL16I68JfRelAE,10089
+sokrates_mcp/workflow.py,sha256=OyiLFbh3bj8fBQYPt1YNjcj9HY3v--xu03PZVmGJgig,13439
+sokrates_mcp-0.2.0.dist-info/licenses/LICENSE,sha256=OgJ7nuNhaIefjDRK0wTGOErJ_c1984Eg9oUweycmal0,1068
+sokrates_mcp_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sokrates_mcp_client/mcp_client_example.py,sha256=L5_xH0u7lt0k0t_eiFFhN9FVU__seFhxHfRixdy14PU,3866
+sokrates_mcp-0.2.0.dist-info/METADATA,sha256=vTdQwxkRk-1NaiVcIDIryvsLlBxWS6tuLGjlyIm-m8A,9475
+sokrates_mcp-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sokrates_mcp-0.2.0.dist-info/entry_points.txt,sha256=7gYOgoyRs_mE6dmwMJrAtrMns2mxv4ZbqXBznRh3sUc,56
+sokrates_mcp-0.2.0.dist-info/top_level.txt,sha256=Nbwxz5Mm6LVkglOxqt4ZyEO5A6D4VjjN8c6d-fQyc3k,33
+sokrates_mcp-0.2.0.dist-info/RECORD,,

sokrates_mcp-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sokrates_mcp-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sokrates-mcp = sokrates_mcp.main:main

sokrates_mcp-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Julian Weber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sokrates_mcp-0.2.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+sokrates_mcp
+sokrates_mcp_client

sokrates_mcp_client/mcp_client_example.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+"""
+This script demonstrates a basic Model Context Protocol (MCP) client
+using the fastmcp library. It defines a simple model and registers it
+with the client, making it ready to receive requests.
+"""
+
+import logging
+from fastmcp import Client, Model
+from fastmcp.context import Context
+from fastmcp.model import ModelInput, ModelOutput
+
+# Configure logging for better visibility of fastmcp operations
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ExampleModel(Model):
+    """
+    A simple example model that processes text input and returns a modified text.
+    This model demonstrates how to define a model and implement its 'call' method.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.name = "example-model"
+        self.version = "1.0.0"
+        logger.info(f"Initialized {self.name} v{self.version}")
+
+    async def call(self, inputs: ModelInput, context: Context) -> ModelOutput:
+        """
+        The core method where the model's logic resides.
+        It takes ModelInput and Context, and returns ModelOutput.
+
+        Args:
+            inputs (ModelInput): The input data for the model.
+                                 Expected to contain a 'text' field.
+            context (Context): The context object providing access to
+                               session information, logging, etc.
+
+        Returns:
+            ModelOutput: The output data from the model.
+                         Contains a 'processed_text' field.
+        """
+        logger.info(f"Model '{self.name}' received a call.")
+        
+        # Access input data. ModelInput is typically a dictionary-like object.
+        input_text = inputs.get("text", "No text provided")
+        logger.info(f"Input text: '{input_text}'")
+
+        # Simulate some processing
+        processed_text = f"Processed: {input_text.upper()} (by {self.name})"
+
+        # You can also access context information, e.g., session ID
+        session_id = context.session_id
+        logger.info(f"Processing for session ID: {session_id}")
+
+        # Return the processed output as a ModelOutput object
+        return ModelOutput({"processed_text": processed_text})
+
+async def main():
+    """
+    Main function to initialize and run the fastmcp client.
+    """
+    logger.info("Starting FastMCP client setup...")
+
+    # Create an instance of the FastMCP client
+    # You can specify the host and port where the client will listen for requests.
+    # By default, it listens on 0.0.0.0:8000
+    client = Client(host="0.0.0.0", port=8000)
+    logger.info(f"FastMCP client initialized on {client.host}:{client.port}")
+
+    # Create an instance of your custom model
+    example_model = ExampleModel()
+
+    # Register the model with the client
+    # The model will be accessible via its name (e.g., "example-model")
+    client.register_model(example_model)
+    logger.info(f"Model '{example_model.name}' registered with the client.")
+
+    # Start the client. This will block and listen for incoming requests.
+    # For a real application, you might integrate this into a larger ASGI server
+    # or a systemd service.
+    logger.info("FastMCP client is starting to listen for requests...")
+    await client.start()
+
+if __name__ == "__main__":
+    # To run this script, you would typically use an ASGI server like Uvicorn:
+    # uvicorn your_script_name:main --factory
+    #
+    # However, for a simple direct run to see it initialize, you can use:
+    import asyncio
+    asyncio.run(main())
+    # Note: Running directly with asyncio.run(main()) will start the server,
+    # but you'll need to send requests to it from another process.
+    # For proper testing, use `uvicorn your_script_name:client.app` after
+    # changing `await client.start()` to `return client.app` in `main()`
+    # and importing `main` as the ASGI app.