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

mcp_agent/resources/examples/workflows/parallel.py

@@ -1,79 +0,0 @@
-"""
-Parallel Workflow showing Fan Out and Fan In agents, using different models
-"""
-
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent(
-    "Parallel Workflow",
-)
-SHORT_STORY = """
-The Battle of Glimmerwood
-
-In the heart of Glimmerwood, a mystical forest knowed for its radiant trees, a small village thrived. 
-The villagers, who were live peacefully, shared their home with the forest's magical creatures, 
-especially the Glimmerfoxes whose fur shimmer like moonlight.
-
-One fateful evening, the peace was shaterred when the infamous Dark Marauders attack. 
-Lead by the cunning Captain Thorn, the bandits aim to steal the precious Glimmerstones which was believed to grant immortality.
-
-Amidst the choas, a young girl named Elara stood her ground, she rallied the villagers and devised a clever plan.
-Using the forests natural defenses they lured the marauders into a trap. 
-As the bandits aproached the village square, a herd of Glimmerfoxes emerged, blinding them with their dazzling light, 
-the villagers seized the opportunity to captured the invaders.
-
-Elara's bravery was celebrated and she was hailed as the "Guardian of Glimmerwood". 
-The Glimmerstones were secured in a hidden grove protected by an ancient spell.
-
-However, not all was as it seemed. The Glimmerstones true power was never confirm, 
-and whispers of a hidden agenda linger among the villagers.
-"""
-
-
-@fast.agent(
-    name="proofreader",
-    instruction=""""Review the short story for grammar, spelling, and punctuation errors.
-    Identify any awkward phrasing or structural issues that could improve clarity. 
-    Provide detailed feedback on corrections.""",
-)
-@fast.agent(
-    name="fact_checker",
-    instruction="""Verify the factual consistency within the story. Identify any contradictions,
-    logical inconsistencies, or inaccuracies in the plot, character actions, or setting. 
-    Highlight potential issues with reasoning or coherence.""",
-    model="gpt-4o",
-)
-@fast.agent(
-    name="style_enforcer",
-    instruction="""Analyze the story for adherence to style guidelines.
-    Evaluate the narrative flow, clarity of expression, and tone. Suggest improvements to 
-    enhance storytelling, readability, and engagement.""",
-    model="sonnet",
-)
-@fast.agent(
-    name="grader",
-    instruction="""Compile the feedback from the Proofreader, Fact Checker, and Style Enforcer
-    into a structured report. Summarize key issues and categorize them by type. 
-    Provide actionable recommendations for improving the story, 
-    and give an overall grade based on the feedback.""",
-    model="o3-mini.low",
-)
-@fast.parallel(
-    fan_out=["proofreader", "fact_checker", "style_enforcer"],
-    fan_in="grader",
-    name="parallel",
-)
-async def main() -> None:
-    # Use the app's context manager
-    async with fast.run() as agent:
-        await agent.parallel(f"student short story submission: {SHORT_STORY}")
-
-        # follow-on prompt to task agent
-        await agent.style_enforcer.prompt(default_prompt="STOP")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/router.py

@@ -1,54 +0,0 @@
-"""
-Example MCP Agent application showing router workflow with decorator syntax.
-Demonstrates router's ability to either:
-1. Use tools directly to handle requests
-2. Delegate requests to specialized agents
-"""
-
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent(
-    "Router Workflow",
-)
-
-# Sample requests demonstrating direct tool use vs agent delegation
-SAMPLE_REQUESTS = [
-    "Download and summarize https://llmindset.co.uk/posts/2024/12/mcp-build-notes/",  # Router handles directly with fetch
-    "Analyze the quality of the Python codebase in the current working directory",  # Delegated to code expert
-    "What are the key principles of effective beekeeping?",  # Delegated to general assistant
-]
-
-
-@fast.agent(
-    name="fetcher",
-    instruction="""You are an agent, with a tool enabling you to fetch URLs.""",
-    servers=["fetch"],
-)
-@fast.agent(
-    name="code_expert",
-    instruction="""You are an expert in code analysis and software engineering.
-    When asked about code, architecture, or development practices,
-    you provide thorough and practical insights.""",
-    servers=["filesystem"],
-)
-@fast.agent(
-    name="general_assistant",
-    instruction="""You are a knowledgeable assistant that provides clear,
-    well-reasoned responses about general topics, concepts, and principles.""",
-)
-@fast.router(
-    name="route",
-    model="sonnet",
-    agents=["code_expert", "general_assistant", "fetcher"],
-)
-async def main() -> None:
-    async with fast.run() as agent:
-        for request in SAMPLE_REQUESTS:
-            await agent.route(request)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/sse.py

@@ -1,23 +0,0 @@
-# example_mcp_server.py
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-
-# Define your agents as normal
-fa = FastAgent("My Application")
-
-
-@fa.agent("analyst", "hello, world", servers=["fetch"])
-
-# Run the application with MCP server
-async def main() -> None:
-    await fa.run_with_mcp_server(
-        transport="sse",  # Use "sse" for web server, "stdio" for command line
-        port=8000,
-        server_name="MyAgents",
-        server_description="MCP Server exposing analyst and researcher agents",
-    )
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/telemetry/usage_tracking.py

@@ -1,19 +0,0 @@
-import logging
-
-from mcp_agent.config import get_settings
-
-logger = logging.getLogger(__name__)
-
-
-def send_usage_data() -> None:
-    config = get_settings()
-    if not config.usage_telemetry.enabled:
-        logger.info("Usage tracking is disabled")
-        return
-
-    # TODO: saqadri - implement usage tracking
-    # data = {"installation_id": str(uuid.uuid4()), "version": "0.1.0"}
-    # try:
-    #     requests.post("https://telemetry.example.com/usage", json=data, timeout=2)
-    # except:
-    #     pass

mcp_agent/workflows/embedding/embedding_base.py

@@ -1,58 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, List
-
-from numpy import float32
-from numpy.typing import NDArray
-from sklearn.metrics.pairwise import cosine_similarity
-
-from mcp_agent.context_dependent import ContextDependent
-
-FloatArray = NDArray[float32]
-
-
-class EmbeddingModel(ABC, ContextDependent):
-    """Abstract interface for embedding models"""
-
-    @abstractmethod
-    async def embed(self, data: List[str]) -> FloatArray:
-        """
-        Generate embeddings for a list of messages
-
-        Args:
-            data: List of text strings to embed
-
-        Returns:
-            Array of embeddings, shape (len(texts), embedding_dim)
-        """
-
-    @property
-    @abstractmethod
-    def embedding_dim(self) -> int:
-        """Return the dimensionality of the embeddings"""
-
-
-def compute_similarity_scores(embedding_a: FloatArray, embedding_b: FloatArray) -> Dict[str, float]:
-    """
-    Compute different similarity metrics between embeddings
-    """
-    # Reshape for sklearn's cosine_similarity
-    a_emb = embedding_a.reshape(1, -1)
-    b_emb = embedding_b.reshape(1, -1)
-
-    cosine_sim = float(cosine_similarity(a_emb, b_emb)[0, 0])
-
-    # Could add other similarity metrics here
-    return {
-        "cosine": cosine_sim,
-        # "euclidean": float(euclidean_similarity),
-        # "dot_product": float(dot_product)
-    }
-
-
-def compute_confidence(similarity_scores: Dict[str, float]) -> float:
-    """
-    Compute overall confidence score from individual similarity metrics
-    """
-    # For now, just use cosine similarity as confidence
-    # Could implement more sophisticated combination of scores
-    return similarity_scores["cosine"]

mcp_agent/workflows/embedding/embedding_cohere.py

@@ -1,49 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from cohere import Client
-from numpy import array, float32
-
-from mcp_agent.workflows.embedding.embedding_base import EmbeddingModel, FloatArray
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class CohereEmbeddingModel(EmbeddingModel):
-    """Cohere embedding model implementation"""
-
-    def __init__(
-        self,
-        model: str = "embed-multilingual-v3.0",
-        context: Optional["Context"] = None,
-        **kwargs,
-    ) -> None:
-        super().__init__(context=context, **kwargs)
-        self.client = Client(api_key=self.context.config.cohere.api_key)
-        self.model = model
-        # Cache the dimension since it's fixed per model
-        # https://docs.cohere.com/v2/docs/cohere-embed
-        self._embedding_dim = {
-            "embed-english-v2.0": 4096,
-            "embed-english-light-v2.0": 1024,
-            "embed-english-v3.0": 1024,
-            "embed-english-light-v3.0": 384,
-            "embed-multilingual-v2.0": 768,
-            "embed-multilingual-v3.0": 1024,
-            "embed-multilingual-light-v3.0": 384,
-        }[model]
-
-    async def embed(self, data: List[str]) -> FloatArray:
-        response = self.client.embed(
-            texts=data,
-            model=self.model,
-            input_type="classification",
-            embedding_types=["float"],
-        )
-
-        embeddings = array(response.embeddings, dtype=float32)
-        return embeddings
-
-    @property
-    def embedding_dim(self) -> int:
-        return self._embedding_dim

mcp_agent/workflows/embedding/embedding_openai.py

@@ -1,37 +0,0 @@
-from typing import TYPE_CHECKING, List, Optional
-
-from numpy import array, float32, stack
-from openai import OpenAI
-
-from mcp_agent.workflows.embedding.embedding_base import EmbeddingModel, FloatArray
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class OpenAIEmbeddingModel(EmbeddingModel):
-    """OpenAI embedding model implementation"""
-
-    def __init__(self, model: str = "text-embedding-3-small", context: Optional["Context"] = None) -> None:
-        super().__init__(context=context)
-        self.client = OpenAI(api_key=self.context.config.openai.api_key)
-        self.model = model
-        # Cache the dimension since it's fixed per model
-        self._embedding_dim = {
-            "text-embedding-3-small": 1536,
-            "text-embedding-3-large": 3072,
-        }[model]
-
-    async def embed(self, data: List[str]) -> FloatArray:
-        response = self.client.embeddings.create(model=self.model, input=data, encoding_format="float")
-
-        # Sort the embeddings by their index to ensure correct order
-        sorted_embeddings = sorted(response.data, key=lambda x: x["index"])
-
-        # Stack all embeddings into a single array
-        embeddings = stack([array(embedding["embedding"], dtype=float32) for embedding in sorted_embeddings])
-        return embeddings
-
-    @property
-    def embedding_dim(self) -> int:
-        return self._embedding_dim