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

mcp_agent/resources/examples/mcp_researcher/researcher-eval.py

@@ -1,53 +0,0 @@
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-
-agents = FastAgent(name="Researcher")
-
-
-@agents.agent(
-    name="Researcher",
-    instruction="""
-You are a research assistant, with access to internet search (via Brave),
-website fetch, a python interpreter (you can install packages with uv) and a filesystem.
-Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
-The interpreter has numpy, pandas, matplotlib and seaborn already installed.
-
-You must always provide a summary of the specific sources you have used in your research.
-    """,
-    servers=["brave", "interpreter", "filesystem", "fetch"],
-)
-@agents.agent(
-    name="Evaluator",
-    model="sonnet",
-    instruction="""
-Evaluate the response from the researcher based on the criteria:
- - Sources cited. Has the researcher provided a summary of the specific sources used in the research?
- - Validity. Has the researcher cross-checked and validated data and assumptions.
- - Alignment. Has the researher acted and addressed feedback from any previous assessments?
- 
-For each criterion:
-- Provide a rating (EXCELLENT, GOOD, FAIR, or POOR).
-- Offer specific feedback or suggestions for improvement.
-
-Summarize your evaluation as a structured response with:
-- Overall quality rating.
-- Specific feedback and areas for improvement.""",
-)
-@agents.evaluator_optimizer(
-    generator="Researcher",
-    evaluator="Evaluator",
-    max_refinements=5,
-    min_rating="EXCELLENT",
-    name="Researcher_Evaluator",
-)
-async def main():
-    async with agents.run() as agent:
-        await agent.prompt("Researcher_Evaluator")
-
-        print("Ask follow up quesions to the Researcher?")
-        await agent.prompt("Researcher", default="STOP")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/researcher/fastagent.config.yaml

@@ -1,66 +0,0 @@
-#
-# Please edit this configuration file to match your environment (on Windows).
-# Examples in comments below - check/change the paths.
-#
-#
-
-execution_engine: asyncio
-logger:
-  type: console
-  level: error
-  truncate_tools: true
-
-mcp:
-  servers:
-    brave:
-      # On windows replace the command and args line to use `node` and the absolute path to the server.
-      # Use `npm i -g @modelcontextprotocol/server-brave-search` to install the server globally.
-      # Use `npm -g root` to find the global node_modules path.`
-      # command: "node"
-      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
-      command: "npx"
-      args: ["-y", "@modelcontextprotocol/server-brave-search"]
-      env:
-        # You can also place your BRAVE_API_KEY in the fastagent.secrets.yaml file.
-        BRAVE_API_KEY: <your_brave_api_key>
-    filesystem:
-      # On windows update the command and arguments to use `node` and the absolute path to the server.
-      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
-      # Use `npm -g root` to find the global node_modules path.`
-      # command: "node"
-      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","./agent_folder"]
-      command: "npx"
-      args: ["-y", "@modelcontextprotocol/server-filesystem", "./agent_folder/"]
-    interpreter:
-      command: "docker"
-      args: [
-          "run",
-          "-i",
-          "--rm",
-          "--pull=always",
-          "-v",
-          "./agent_folder:/mnt/data/",
-          # Docker needs the absolute path on Windows (e.g. "x:/fastagent/agent_folder:/mnt/data/")
-          # "./agent_folder:/mnt/data/",
-          "ghcr.io/evalstate/mcp-py-repl:latest",
-        ]
-      roots:
-        - uri: "file://./agent_folder/"
-          name: "agent_folder"
-          server_uri_alias: "file:///mnt/data/"
-    fetch:
-      command: "uvx"
-      args: ["mcp-server-fetch"]
-    sequential:
-      command: "npx"
-      args: ["-y","@modelcontextprotocol/server-sequential-thinking"]
-
-#    webmcp:
-#      command: "node"
-#      args: ["/home/ssmith/.webmcp/server.cjs"]
-#      env:
-#         WEBMCP_SERVER_TOKEN: 96e22896d8143fc1d61fec09208fc5ed
-
-
-
-

mcp_agent/resources/examples/researcher/researcher-eval.py

@@ -1,53 +0,0 @@
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-
-agents = FastAgent(name="Researcher Agent (EO)")
-
-
-@agents.agent(
-    name="Researcher",
-    instruction="""
-You are a research assistant, with access to internet search (via Brave),
-website fetch, a python interpreter (you can install packages with uv) and a filesystem.
-Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
-The interpreter has numpy, pandas, matplotlib and seaborn already installed.
-
-You must always provide a summary of the specific sources you have used in your research.
-    """,
-    servers=["brave", "interpreter", "filesystem", "fetch"],
-)
-@agents.agent(
-    name="Evaluator",
-    model="sonnet",
-    instruction="""
-Evaluate the response from the researcher based on the criteria:
- - Sources cited. Has the researcher provided a summary of the specific sources used in the research?
- - Validity. Has the researcher cross-checked and validated data and assumptions.
- - Alignment. Has the researher acted and addressed feedback from any previous assessments?
- 
-For each criterion:
-- Provide a rating (EXCELLENT, GOOD, FAIR, or POOR).
-- Offer specific feedback or suggestions for improvement.
-
-Summarize your evaluation as a structured response with:
-- Overall quality rating.
-- Specific feedback and areas for improvement.""",
-)
-@agents.evaluator_optimizer(
-    generator="Researcher",
-    evaluator="Evaluator",
-    max_refinements=5,
-    min_rating="EXCELLENT",
-    name="Researcher_Evaluator",
-)
-async def main():
-    async with agents.run() as agent:
-        await agent.prompt("Researcher_Evaluator")
-
-        print("Ask follow up quesions to the Researcher?")
-        await agent.prompt("Researcher", default="STOP")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/researcher/researcher-imp.py

@@ -1,190 +0,0 @@
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-agents = FastAgent(name="Enhanced Researcher")
-
-
-@agents.agent(
-    name="ResearchPlanner",
-    model="sonnet",  # Using a more capable model for planning
-    instruction="""
-You are a strategic research planner. Your job is to:
-1. Break down complex research questions into specific sub-questions
-2. Identify the key information sources needed to answer each sub-question
-3. Outline a structured research plan
-
-When given a research topic:
-- Analyze what is being asked and identify the core components
-- Define 3-5 specific sub-questions that need to be answered
-- For each sub-question, suggest specific search queries and information sources
-- Prioritize the most important areas to investigate first
-- Include suggestions for data visualization or analysis if appropriate
-
-Your output should be a clear, structured research plan that the Researcher can follow.
-""",
-    servers=["brave"],
-)
-@agents.agent(
-    name="Researcher",
-    model="sonnet",  # Using a more capable model for deep research
-    instruction="""
-You are an expert research assistant with access to multiple resources:
-- Brave Search for initial exploration and discovering sources
-- Website fetching to read and extract information directly from webpages
-- Python interpreter for data analysis and visualization
-- Filesystem tools to save and organize your findings
-
-RESEARCH METHODOLOGY:
-1. First understand the research plan provided
-2. For each sub-question, use search tools to find multiple relevant sources
-3. Go beyond surface-level information by:
-   - Consulting primary sources when possible
-   - Cross-referencing information across multiple sources
-   - Using the fetch tool to access complete articles rather than just search snippets
-   - Analyzing data with Python when numerical evidence is needed
-   - Creating visualizations when they help clarify complex information
-
-CRITICAL INFORMATION ASSESSMENT:
-- Evaluate the credibility of each source (consider recency, authority, potential bias)
-- Look for consensus across multiple sources
-- Highlight any contradictions or areas of debate in the research
-- Clearly state limitations in the available information
-
-DOCUMENTATION:
-- Save important information, data, and visualizations to files
-- Always create a comprehensive bibliography with links to all sources
-- Include specific citation details (author, date, publication) when available
-- Note which specific information came from which source
-
-FINAL RESPONSE:
-- Structure your findings logically with clear headings
-- Synthesize the information rather than just listing facts
-- Directly address each sub-question from the research plan
-- Use data and visualizations to support key points
-- End with a concise executive summary of your findings
-- Include a "Methodology" section explaining how you conducted your research
-""",
-    servers=["brave", "interpreter", "filesystem", "fetch"],
-    use_history=True,
-)
-@agents.agent(
-    name="FactChecker",
-    instruction="""
-You are a meticulous fact-checker and critical evaluator of research. Your responsibilities are to:
-
-1. Verify factual claims by cross-checking with authoritative sources
-2. Identify any unsupported assertions or logical fallacies
-3. Detect potential biases or limitations in the research methodology
-4. Ensure proper representation of diverse perspectives on controversial topics
-5. Evaluate the quality, reliability, and currency of cited sources
-
-When reviewing research:
-- Flag any claims that lack sufficient evidence or citation
-- Identify information that seems outdated or contradicts current consensus
-- Check for oversimplifications of complex topics
-- Ensure numerical data and statistics are accurately represented
-- Verify that quotations are accurate and in proper context
-- Look for any gaps in the research or important perspectives that were omitted
-
-Your feedback should be specific, actionable, and structured to help improve accuracy and comprehensiveness.
-""",
-    servers=["brave", "fetch"],
-)
-@agents.agent(
-    name="Evaluator",
-    model="sonnet",
-    instruction="""
-You are a senior research quality evaluator with expertise in academic and professional research standards.
-
-COMPREHENSIVE EVALUATION CRITERIA:
-1. Research Methodology
-   - Has the researcher followed a structured approach?
-   - Were appropriate research methods applied?
-   - Is there evidence of strategic information gathering?
-
-2. Source Quality & Diversity
-   - Are sources authoritative, current, and relevant?
-   - Is there appropriate diversity of sources?
-   - Were primary sources consulted when appropriate?
-
-3. Information Depth
-   - Does the research go beyond surface-level information?
-   - Is there evidence of in-depth analysis?
-   - Has the researcher explored multiple aspects of the topic?
-
-4. Critical Analysis
-   - Has information been critically evaluated rather than simply reported?
-   - Are limitations and uncertainties acknowledged?
-   - Are multiple perspectives considered on controversial topics?
-
-5. Data & Evidence
-   - Is quantitative data properly analyzed and presented?
-   - Are visualizations clear, accurate, and informative?
-   - Is qualitative information presented with appropriate context?
-
-6. Documentation & Attribution
-   - Are all sources properly cited with complete reference information?
-   - Is it clear which information came from which source?
-   - Is the bibliography comprehensive and well-formatted?
-
-7. Structure & Communication
-   - Is the research presented in a logical, well-organized manner?
-   - Are findings communicated clearly and precisely?
-   - Is the level of technical language appropriate for the intended audience?
-
-8. Alignment with Previous Feedback
-   - Has the researcher addressed specific feedback from previous evaluations?
-   - Have requested improvements been successfully implemented?
-
-For each criterion, provide:
-- A detailed RATING (EXCELLENT, GOOD, FAIR, or POOR)
-- Specific examples from the research that justify your rating
-- Clear, actionable suggestions for improvement
-
-Your evaluation should conclude with:
-- An OVERALL RATING that reflects the research quality
-- A concise summary of the research's major strengths
-- A prioritized list of the most important areas for improvement
-
-The researcher should be able to understand exactly why they received their rating and what specific steps they can take to improve.
-""",
-)
-@agents.chain(
-    name="ResearchProcess",
-    sequence=["ResearchPlanner", "Researcher", "FactChecker"],
-    instruction="A comprehensive research workflow that plans, executes, and verifies research",
-    cumulative=True,
-)
-@agents.evaluator_optimizer(
-    generator="ResearchProcess",
-    evaluator="Evaluator",
-    max_refinements=3,
-    min_rating="EXCELLENT",
-    name="EnhancedResearcher",
-)
-async def main():
-    async with agents.run() as agent:
-        # Start with a warm-up to set expectations and explain the research approach
-        await agent.Researcher.send(
-            """I'm an enhanced research assistant trained to conduct thorough, evidence-based research. 
-            I'll approach your question by:
-            1. Creating a structured research plan
-            2. Gathering information from multiple authoritative sources
-            3. Analyzing data and creating visualizations when helpful
-            4. Fact-checking and verifying all information
-            5. Providing a comprehensive, well-documented answer
-
-            What would you like me to research for you today?"""
-        )
-
-        # Start the main research workflow
-        await agent.prompt("EnhancedResearcher")
-
-        print(
-            "\nWould you like to ask follow-up questions to the Researcher? (Type 'STOP' to end)"
-        )
-        await agent.prompt("Researcher", default="STOP")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/researcher/researcher.py

@@ -1,38 +0,0 @@
-import asyncio
-
-from mcp_agent.core.fastagent import FastAgent
-# from rich import print
-
-agents = FastAgent(name="Researcher Agent")
-
-
-@agents.agent(
-    "Researcher",
-    instruction="""
-You are a research assistant, with access to internet search (via Brave),
-website fetch, a python interpreter (you can install packages with uv) and a filesystem.
-Use the current working directory to save and create files with both the Interpreter and Filesystem tools.
-The interpreter has numpy, pandas, matplotlib and seaborn already installed
-    """,
-    servers=["brave", "interpreter", "filesystem", "fetch"],
-)
-async def main():
-    research_prompt = """
-Produce an investment report for the company Eutelsat. The final report should be saved in the filesystem in markdown format, and
-contain at least the following: 
-1 - A brief description of the company
-2 - Current financial position (find data, create and incorporate charts)
-3 - A PESTLE analysis
-4 - An investment thesis for the next 3 years. Include both 'buy side' and 'sell side' arguments, and a final 
-summary and recommendation.
-Todays date is 15 February 2025. Include the main data sources consulted in presenting the report."""  # noqa: F841
-
-    async with agents.run() as agent:
-        await agent.prompt()
-
-        # await agent.prompt(default="STOP")
-        #        await agent.prompt(default=research_prompt)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/chaining.py

@@ -1,44 +0,0 @@
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent("Agent Chaining")
-
-
-@fast.agent(
-    "url_fetcher",
-    instruction="Given a URL, provide a complete and comprehensive summary",
-    servers=["fetch"],
-)
-@fast.agent(
-    "social_media",
-    instruction="""
-    Write a 280 character social media post for any given text. 
-    Respond only with the post, never use hashtags.
-    """,
-)
-@fast.chain(
-    name="post_writer",
-    sequence=["url_fetcher", "social_media"],
-)
-async def main():
-    async with fast.run() as agent:
-        # using chain workflow
-        await agent.post_writer.prompt()
-
-        # calling directly
-        # await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
-        # await agent.social_media(
-        #     await agent.url_fetcher("http://llmindset.co.uk/resources/mcp-hfspace/")
-        # )
-
-        # agents can also be accessed like dictionaries:
-        # awwait agent["post_writer"].prompt()
-
-
-# alternative syntax for above is result = agent["post_writer"].send(message)
-# alternative syntax for above is result = agent["post_writer"].prompt()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/evaluator.py

@@ -1,78 +0,0 @@
-"""
-This demonstrates creating an optimizer and evaluator to iteratively improve content.
-"""
-
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent("Evaluator-Optimizer")
-
-
-# Define generator agent
-@fast.agent(
-    name="generator",
-    instruction="""You are a career coach specializing in cover letter writing.
-    You are tasked with generating a compelling cover letter given the job posting,
-    candidate details, and company information. Tailor the response to the company and job requirements.
-    """,
-    servers=["fetch"],
-    model="haiku3",
-    use_history=True,
-)
-# Define evaluator agent
-@fast.agent(
-    name="evaluator",
-    instruction="""Evaluate the following response based on the criteria below:
-    1. Clarity: Is the language clear, concise, and grammatically correct?
-    2. Specificity: Does the response include relevant and concrete details tailored to the job description?
-    3. Relevance: Does the response align with the prompt and avoid unnecessary information?
-    4. Tone and Style: Is the tone professional and appropriate for the context?
-    5. Persuasiveness: Does the response effectively highlight the candidate's value?
-    6. Grammar and Mechanics: Are there any spelling or grammatical issues?
-    7. Feedback Alignment: Has the response addressed feedback from previous iterations?
-
-    For each criterion:
-    - Provide a rating (EXCELLENT, GOOD, FAIR, or POOR).
-    - Offer specific feedback or suggestions for improvement.
-
-    Summarize your evaluation as a structured response with:
-    - Overall quality rating.
-    - Specific feedback and areas for improvement.""",
-    model="gpt-4o",
-)
-# Define the evaluator-optimizer workflow
-@fast.evaluator_optimizer(
-    name="cover_letter_writer",
-    generator="generator",  # Reference to generator agent
-    evaluator="evaluator",  # Reference to evaluator agent
-    min_rating="EXCELLENT",  # Strive for excellence
-    max_refinements=3,  # Maximum iterations
-)
-async def main():
-    async with fast.run() as agent:
-        job_posting = (
-            "Software Engineer at LastMile AI. Responsibilities include developing AI systems, "
-            "collaborating with cross-functional teams, and enhancing scalability. Skills required: "
-            "Python, distributed systems, and machine learning."
-        )
-        candidate_details = (
-            "Alex Johnson, 3 years in machine learning, contributor to open-source AI projects, "
-            "proficient in Python and TensorFlow. Motivated by building scalable AI systems to solve real-world problems."
-        )
-        company_information = (
-            "Look up from the LastMile AI About page: https://lastmileai.dev/about"
-        )
-
-        # Send the task
-        await agent.cover_letter_writer.send(
-            f"Write a cover letter for the following job posting: {job_posting}\n\n"
-            f"Candidate Details: {candidate_details}\n\n"
-            f"Company information: {company_information}",
-        )
-
-        await agent()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/fastagent.config.yaml

@@ -1,24 +0,0 @@
-# Please edit this configuration file to match your environment (on Windows).
-# Examples in comments below - check/change the paths.
-#
-#
-
-execution_engine: asyncio
-logger:
-  type: file
-  level: error
-  truncate_tools: true
-
-mcp:
-  servers:
-    filesystem:
-      # On windows update the command and arguments to use `node` and the absolute path to the server.
-      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
-      # Use `npm -g root` to find the global node_modules path.`
-      # command: "node"
-      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","."]
-      command: "npx"
-      args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
-    fetch:
-      command: "uvx"
-      args: ["mcp-server-fetch"]

mcp_agent/resources/examples/workflows/human_input.py

@@ -1,25 +0,0 @@
-"""
-Agent which demonstrates Human Input tool
-"""
-
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent("Human Input")
-
-
-# Define the agent
-@fast.agent(
-    instruction="An AI agent that assists with basic tasks. Request Human Input when needed.",
-    human_input=True,
-)
-async def main():
-    async with fast.run() as agent:
-        # this usually causes the LLM to request the Human Input Tool
-        await agent("print the next number in the sequence")
-        await agent.prompt(default="STOP")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -1,73 +0,0 @@
-"""
-This demonstrates creating multiple agents and an orchestrator to coordinate them.
-"""
-
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent("Orchestrator-Workers")
-
-
-@fast.agent(
-    "author",
-    instruction="""You are to role play a poorly skilled writer, 
-    who makes frequent grammar, punctuations and spelling errors. You enjoy
-    writing short stories, but the narrative doesn't always make sense""",
-    servers=["filesystem"],
-)
-# Define worker agents
-@fast.agent(
-    name="finder",
-    instruction="""You are an agent with access to the filesystem, 
-            as well as the ability to fetch URLs. Your job is to identify 
-            the closest match to a user's request, make the appropriate tool calls, 
-            and return the URI and CONTENTS of the closest match.""",
-    servers=["fetch", "filesystem"],
-    model="gpt-4o",
-)
-@fast.agent(
-    name="writer",
-    instruction="""You are an agent that can write to the filesystem.
-            You are tasked with taking the user's input, addressing it, and 
-            writing the result to disk in the appropriate location.""",
-    servers=["filesystem"],
-)
-@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.""",
-    servers=["fetch"],
-    model="gpt-4o",
-)
-# Define the orchestrator to coordinate the other agents
-@fast.orchestrator(
-    name="orchestrate",
-    agents=["finder", "writer", "proofreader"],
-    plan_type="iterative",
-)
-async def main():
-    async with fast.run() as agent:
-        await agent()
-        await agent.author(
-            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-        )
-
-        # The orchestrator can be used just like any other agent
-        task = (
-            """Load the student's short story from short_story.md, 
-        and generate a report with feedback across proofreading, 
-        factuality/logical consistency and style adherence. Use the style rules from 
-        https://apastyle.apa.org/learn/quick-guide-on-formatting and 
-        https://apastyle.apa.org/learn/quick-guide-on-references.
-        Write the graded report to graded_report.md in the same directory as short_story.md""",
-        )
-
-        # Send the task
-        await agent.orchestrate(task)
-        await agent()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())