fast-agent-mcp 0.1.13__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_agent/workflows/intent_classifier/intent_classifier_embedding_cohere.py

@@ -1,41 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from mcp_agent.workflows.embedding.embedding_cohere import CohereEmbeddingModel
-from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
-from mcp_agent.workflows.intent_classifier.intent_classifier_embedding import (
-    EmbeddingIntentClassifier,
-)
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class CohereEmbeddingIntentClassifier(EmbeddingIntentClassifier):
-    """
-    An intent classifier that uses Cohere's embedding models for computing semantic simiarity based classifications.
-    """
-
-    def __init__(
-        self,
-        intents: List[Intent],
-        embedding_model: CohereEmbeddingModel | None = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        embedding_model = embedding_model or CohereEmbeddingModel()
-        super().__init__(embedding_model=embedding_model, intents=intents, context=context, **kwargs)
-
-    @classmethod
-    async def create(
-        cls,
-        intents: List[Intent],
-        embedding_model: CohereEmbeddingModel | None = None,
-        context: Optional["Context"] = None,
-    ) -> "CohereEmbeddingIntentClassifier":
-        """
-        Factory method to create and initialize a classifier.
-        Use this instead of constructor since we need async initialization.
-        """
-        instance = cls(intents=intents, embedding_model=embedding_model, context=context)
-        await instance.initialize()
-        return instance

mcp_agent/workflows/intent_classifier/intent_classifier_embedding_openai.py

@@ -1,41 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from mcp_agent.workflows.embedding.embedding_openai import OpenAIEmbeddingModel
-from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
-from mcp_agent.workflows.intent_classifier.intent_classifier_embedding import (
-    EmbeddingIntentClassifier,
-)
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class OpenAIEmbeddingIntentClassifier(EmbeddingIntentClassifier):
-    """
-    An intent classifier that uses OpenAI's embedding models for computing semantic simiarity based classifications.
-    """
-
-    def __init__(
-        self,
-        intents: List[Intent],
-        embedding_model: OpenAIEmbeddingModel | None = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        embedding_model = embedding_model or OpenAIEmbeddingModel()
-        super().__init__(embedding_model=embedding_model, intents=intents, context=context, **kwargs)
-
-    @classmethod
-    async def create(
-        cls,
-        intents: List[Intent],
-        embedding_model: OpenAIEmbeddingModel | None = None,
-        context: Optional["Context"] = None,
-    ) -> "OpenAIEmbeddingIntentClassifier":
-        """
-        Factory method to create and initialize a classifier.
-        Use this instead of constructor since we need async initialization.
-        """
-        instance = cls(intents=intents, embedding_model=embedding_model, context=context)
-        await instance.initialize()
-        return instance

mcp_agent/workflows/intent_classifier/intent_classifier_llm.py

@@ -1,150 +0,0 @@
-from typing import TYPE_CHECKING, List, Literal, Optional
-
-from pydantic import BaseModel
-
-from mcp_agent.workflows.intent_classifier.intent_classifier_base import (
-    Intent,
-    IntentClassificationResult,
-    IntentClassifier,
-)
-from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-DEFAULT_INTENT_CLASSIFICATION_INSTRUCTION = """
-You are a precise intent classifier that analyzes user requests to determine their intended action or purpose.
-Below are the available intents with their descriptions and examples:
-
-{context}
-
-Your task is to analyze the following request and determine the most likely intent(s). Consider:
-- How well the request matches the intent descriptions and examples
-- Any specific entities or parameters that should be extracted
-- The confidence level in the classification
-
-Request: {request}
-
-Respond in JSON format:
-{{
-    "classifications": [
-        {{
-            "intent": <intent name>,
-            "confidence": <float between 0 and 1>,
-            "extracted_entities": {{
-                "entity_name": "entity_value"
-            }},
-            "reasoning": <brief explanation>
-        }}
-    ]
-}}
-
-Return up to {top_k} most likely intents. Only include intents with reasonable confidence (>0.5).
-If no intents match well, return an empty list.
-"""
-
-
-class LLMIntentClassificationResult(IntentClassificationResult):
-    """The result of intent classification using an LLM."""
-
-    confidence: Literal["low", "medium", "high"]
-    """Confidence level of the classification"""
-
-    reasoning: str | None = None
-    """Optional explanation of why this intent was chosen"""
-
-
-class StructuredIntentResponse(BaseModel):
-    """The complete structured response from the LLM"""
-
-    classifications: List[LLMIntentClassificationResult]
-
-
-class LLMIntentClassifier(IntentClassifier):
-    """
-    An intent classifier that uses an LLM to determine the user's intent.
-    Particularly useful when you need:
-    - Flexible understanding of natural language
-    - Detailed reasoning about classifications
-    - Entity extraction alongside classification
-    """
-
-    def __init__(
-        self,
-        llm: AugmentedLLM,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(intents=intents, context=context, **kwargs)
-        self.llm = llm
-        self.classification_instruction = classification_instruction
-
-    @classmethod
-    async def create(
-        cls,
-        llm: AugmentedLLM,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-    ) -> "LLMIntentClassifier":
-        """
-        Factory method to create and initialize a classifier.
-        Use this instead of constructor since we need async initialization.
-        """
-        instance = cls(
-            llm=llm,
-            intents=intents,
-            classification_instruction=classification_instruction,
-        )
-        await instance.initialize()
-        return instance
-
-    async def classify(self, request: str, top_k: int = 1) -> List[LLMIntentClassificationResult]:
-        if not self.initialized:
-            self.initialize()
-
-        classification_instruction = self.classification_instruction or DEFAULT_INTENT_CLASSIFICATION_INSTRUCTION
-
-        # Generate the context with intent descriptions and examples
-        context = self._generate_context()
-
-        # Format the prompt with all the necessary information
-        prompt = classification_instruction.format(context=context, request=request, top_k=top_k)
-
-        # Get classification from LLM
-        response = await self.llm.generate_structured(message=prompt, response_model=StructuredIntentResponse)
-
-        if not response or not response.classifications:
-            return []
-
-        results = []
-        for classification in response.classifications:
-            intent = self.intents.get(classification.intent)
-            if not intent:
-                # Skip invalid categories
-                # TODO: saqadri - log or raise an error
-                continue
-
-            results.append(classification)
-
-        return results[:top_k]
-
-    def _generate_context(self) -> str:
-        """Generate a formatted context string describing all intents"""
-        context_parts = []
-
-        for idx, intent in enumerate(self.intents.values(), 1):
-            description = f"{idx}. Intent: {intent.name}\nDescription: {intent.description}"
-
-            if intent.examples:
-                examples = "\n".join(f"- {example}" for example in intent.examples)
-                description += f"\nExamples:\n{examples}"
-
-            if intent.metadata:
-                metadata = "\n".join(f"- {key}: {value}" for key, value in intent.metadata.items())
-                description += f"\nAdditional Information:\n{metadata}"
-
-            context_parts.append(description)
-
-        return "\n\n".join(context_parts)

mcp_agent/workflows/intent_classifier/intent_classifier_llm_anthropic.py

@@ -1,60 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
-from mcp_agent.workflows.intent_classifier.intent_classifier_llm import (
-    LLMIntentClassifier,
-)
-from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-CLASSIFIER_SYSTEM_INSTRUCTION = """
-You are a precise intent classifier that analyzes input requests to determine their intended action or purpose.
-You are provided with a request and a list of intents to choose from.
-You can choose one or more intents, or choose none if no intent is appropriate.
-"""
-
-
-class AnthropicLLMIntentClassifier(LLMIntentClassifier):
-    """
-    An LLM router that uses an Anthropic model to make routing decisions.
-    """
-
-    def __init__(
-        self,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        anthropic_llm = AnthropicAugmentedLLM(
-            instruction=CLASSIFIER_SYSTEM_INSTRUCTION, context=context
-        )
-
-        super().__init__(
-            llm=anthropic_llm,
-            intents=intents,
-            classification_instruction=classification_instruction,
-            context=context,
-            **kwargs,
-        )
-
-    @classmethod
-    async def create(
-        cls,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-        context: Optional["Context"] = None,
-    ) -> "AnthropicLLMIntentClassifier":
-        """
-        Factory method to create and initialize a classifier.
-        Use this instead of constructor since we need async initialization.
-        """
-        instance = cls(
-            intents=intents,
-            classification_instruction=classification_instruction,
-            context=context,
-        )
-        await instance.initialize()
-        return instance

mcp_agent/workflows/intent_classifier/intent_classifier_llm_openai.py

@@ -1,58 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from mcp_agent.workflows.intent_classifier.intent_classifier_base import Intent
-from mcp_agent.workflows.intent_classifier.intent_classifier_llm import (
-    LLMIntentClassifier,
-)
-from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-CLASSIFIER_SYSTEM_INSTRUCTION = """
-You are a precise intent classifier that analyzes input requests to determine their intended action or purpose.
-You are provided with a request and a list of intents to choose from.
-You can choose one or more intents, or choose none if no intent is appropriate.
-"""
-
-
-class OpenAILLMIntentClassifier(LLMIntentClassifier):
-    """
-    An LLM router that uses an OpenAI model to make routing decisions.
-    """
-
-    def __init__(
-        self,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        openai_llm = OpenAIAugmentedLLM(instruction=CLASSIFIER_SYSTEM_INSTRUCTION, context=context)
-
-        super().__init__(
-            llm=openai_llm,
-            intents=intents,
-            classification_instruction=classification_instruction,
-            context=context,
-            **kwargs,
-        )
-
-    @classmethod
-    async def create(
-        cls,
-        intents: List[Intent],
-        classification_instruction: str | None = None,
-        context: Optional["Context"] = None,
-    ) -> "OpenAILLMIntentClassifier":
-        """
-        Factory method to create and initialize a classifier.
-        Use this instead of constructor since we need async initialization.
-        """
-        instance = cls(
-            intents=intents,
-            classification_instruction=classification_instruction,
-            context=context,
-        )
-        await instance.initialize()
-        return instance

mcp_agent/workflows/llm/augmented_llm_playback.py

@@ -1,111 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional, Union
-
-from mcp import GetPromptResult
-
-from mcp_agent.workflows.llm.augmented_llm import MessageParamT, RequestParams
-from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
-
-if TYPE_CHECKING:
-    from mcp.types import PromptMessage
-
-
-# TODO -- support tool calling
-class PlaybackLLM(PassthroughLLM):
-    """
-    A specialized LLM implementation that plays back assistant messages when loaded with prompts.
-
-    Unlike the PassthroughLLM which simply passes through messages without modification,
-    PlaybackLLM is designed to simulate a conversation by playing back prompt messages
-    in sequence when loaded with prompts through apply_prompt_template.
-
-    After apply_prompts has been called, each call to generate_str returns the next
-    "ASSISTANT" message in the loaded messages. If no messages are set or all messages have
-    been played back, it returns a message indicating that messages are exhausted.
-    """
-
-    def __init__(self, name: str = "Playback", **kwargs) -> None:
-        super().__init__(name=name, **kwargs)
-        self._messages: List[PromptMessage] = []
-        self._current_index = 0
-
-    async def generate_str(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> str:
-        """
-        Return the next ASSISTANT message in the loaded messages list.
-        If no messages are available or all have been played back,
-        returns a message indicating messages are exhausted.
-
-        Note: Only assistant messages are returned; user messages are skipped.
-        """
-        self.show_user_message(message, model="fastagent-playback", chat_turn=0)
-
-        if not self._messages or self._current_index >= len(self._messages):
-            size = len(self._messages) if self._messages else 0
-            response = f"MESSAGES EXHAUSTED (list size {size})"
-        else:
-            response = self._get_next_assistant_message()
-
-        await self.show_assistant_message(response, title="ASSISTANT/PLAYBACK")
-        return response
-
-    def _get_next_assistant_message(self) -> str:
-        """
-        Get the next assistant message from the loaded messages.
-        Increments the current message index and skips user messages.
-        """
-        # Find next assistant message
-        while self._current_index < len(self._messages):
-            message = self._messages[self._current_index]
-            self._current_index += 1
-
-            # Skip non-assistant messages
-            if getattr(message, "role", None) != "assistant":
-                continue
-
-            # Get content as string
-            content = message.content
-            if hasattr(content, "text"):
-                return content.text
-            return str(content)
-
-        # If we get here, we've run out of assistant messages
-        return f"MESSAGES EXHAUSTED (list size {len(self._messages)})"
-
-    async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
-        """
-        Apply a prompt template by adding its messages to the playback queue.
-
-        Args:
-            prompt_result: The GetPromptResult containing prompt messages
-            prompt_name: The name of the prompt being applied
-
-        Returns:
-            String representation of the first message or an indication that no messages were added
-        """
-        prompt_messages: List[PromptMessage] = prompt_result.messages
-
-        # Extract arguments if they were stored in the result
-        arguments = getattr(prompt_result, "arguments", None)
-
-        # Display information about the loaded prompt
-        await self.show_prompt_loaded(
-            prompt_name=prompt_name,
-            description=prompt_result.description,
-            message_count=len(prompt_messages),
-            arguments=arguments,
-        )
-
-        # Add new messages to the end of the existing messages list
-        self._messages.extend(prompt_messages)
-
-        if not prompt_messages:
-            return "Prompt contains no messages"
-
-        # Reset current index if this is the first time loading messages
-        if len(self._messages) == len(prompt_messages):
-            self._current_index = 0
-
-        return f"Added {len(prompt_messages)} messages to playback queue"

mcp_agent/workflows/llm/providers/__init__.py

@@ -1,8 +0,0 @@
-from mcp_agent.workflows.llm.providers.sampling_converter_anthropic import (
-    AnthropicSamplingConverter,
-)
-from mcp_agent.workflows.llm.providers.sampling_converter_openai import (
-    OpenAISamplingConverter,
-)
-
-__all__ = ["AnthropicSamplingConverter", "OpenAISamplingConverter"]