Edvaldo Melo

from fastmcp import FastMCP
import requests
import os
from dotenv import load_dotenv

load_dotenv()


mcp_server = FastMCP("SendEmailMCP")


@mcp_server.tool()
def send_email(to_email: str, subject: str, content: str) -> str:
    """
    Sends an email using the Mailgun API.

    Args:
        to_email (str): Recipient's email address.
        subject (str): Email subject.
        content (str): Plain text body of the email.

    Returns:
        str: Status code of the response if the email is successfully sent, or an error message in case of failure.
    """

    api_key = os.getenv("MAILGUN_API_KEY")
    domain = os.getenv("MAILGUN_DOMAIN")

    try:
        response = requests.post(
            f"https://api.mailgun.net/v3/{domain}/messages",
            auth=("api", api_key),
            data={
                "from": f"Mailgun Sandbox <mailgun@{domain}>",
                "to": [to_email],
                "subject": subject,
                "html": content
            }
        )

        return f"Status Code: {response.status_code}"
    except Exception as e:
        return f"Error sending email: {e}"    


if __name__ == "__main__":
    mcp_server.run(transport="sse", host="0.0.0.0", port=4000)

from langchain_mcp_adapters.client import MultiServerMCPClient
import os
from dotenv import load_dotenv

load_dotenv()

SMITHERY_KEY = os.getenv("SMITHERY_KEY")
SMITHERY_PROFILE = os.getenv("SMITHERY_PROFILE")


def get_mcp_client():

    client = MultiServerMCPClient({
        "mcp-server-serper": {
            "command": "npx",
            "args": [
                "-y",
                "@smithery/cli@latest",
                "run",
                "@marcopesani/mcp-server-serper",
                "--key",
                SMITHERY_KEY,
                "--profile",
                SMITHERY_PROFILE
            ],
            "transport": "stdio",
        },
        "mcp-server-send-email": {
            "transport": "sse",
            "url": "http://localhost:4000/sse/"
        }
    })


    return client

from langchain_core.messages import SystemMessage
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent


class ReportAgent:

    def __init__(self, tools):

        self.__tools = tools
    

    def create_agent(self, boss_name:str, boss_email:str, user_name:str):
        
        prompt = (
            "You are responsible for sending an informative email to my boss containing a clear and well-researched report on a specified topic.\n\n"
            "Instructions:\n"
            "1. Research the given topic on the internet. Your research should cover:\n"
            "- What the topic is (definition and purpose).\n"
            "- Key points, concepts, or relevant aspects.\n"
            "- Relevant data, updated statistics, or trustworthy studies that support the content.\n"
            "2. Write an email in HTML format, with:\n"
            "- A professional, clear, and objective tone.\n"
            "- A well-organized structure (title, introduction, main topics, and conclusion).\n"
            "- Enough information for the recipient to understand the topic and reflect on potential actions or strategies.\n"
            "3. Finally, send the email using the send_email tool.\n\n"
            "Remember: the goal is to inform and encourage productive discussions about the topic. The content must be reliable, direct, and "
            "relevant for decision-making.\n\n"
            "Informations:\n"
            f"- Boss's name: {boss_name}\n"
            f"- Boss email: {boss_email}\n"
            f"- My name: {user_name}"
        )

        model = ChatOpenAI(model="gpt-4o")

        agent = create_react_agent(
            model=model,
            tools=self.__tools,
            prompt=SystemMessage(content=prompt)
        )

        return agent

import asyncio
from mcp_client import get_mcp_client
from report_agent import ReportAgent
from dotenv import load_dotenv

load_dotenv()


async def main():
    client = get_mcp_client()

    tools = await client.get_tools()

    agent = ReportAgent(tools=tools)

    report_agent = agent.create_agent(
        boss_name="Martin",
        boss_email="e***i@gmail.com",
        user_name="Edvaldo Melo"
    )

    resp = await report_agent.ainvoke({"messages": "The topic is Agent2Agent protocol."})
    print(resp['messages'][-1].content)


if __name__ == "__main__":
    asyncio.run(main())

from mcp import StdioServerParameters
from dotenv import load_dotenv
import os

load_dotenv()

SMITHERY_KEY = os.getenv("SMITHERY_KEY")
SMITHERY_PROFILE = os.getenv("SMITHERY_PROFILE")


def get_mcp_servers():

    mcp_serper = StdioServerParameters(
        command="npx",
        args=[
            "-y",
            "@smithery/cli@latest",
            "run",
            "@marcopesani/mcp-server-serper",
            "--key",
            SMITHERY_KEY,
            "--profile",
            SMITHERY_PROFILE
        ]
    )

    mcp_send_email = {
        "transport": "sse",
        "url": "http://localhost:4000/sse/"
    }

    mcp_servers = [mcp_serper, mcp_send_email]

    return mcp_servers

from crewai import Agent, Task, Crew, Process


class ReportAgent:

    def __init__(self, tools):

        self.__tools = tools
    

    def create_crew(self):

        report_agent = Agent(
            role="Report Agent",
            goal=(
                "Research a given topic thoroughly, synthesize key information into a clear, concise, and well-structured report email, and " 
                "send it to the user's boss to inform and support decision-making."
            ),
            backstory=(
                "You are a skilled professional report writer and communicator with expertise in conducting online research, extracting "
                "relevant and trustworthy data, and crafting professional emails in HTML format. You understand the importance of clarity, "
                "objectivity, and relevance when informing leadership to encourage strategic discussions and actions."
            ),
            tools=self.__tools,
            reasoning=True,
            verbose=True
        )

        report = Task(
            description=(
                "User input: {user_input}\n\n"
                "You are responsible for sending an informative email to my boss containing a clear and well-researched report on a specified topic.\n\n"
                "Instructions:\n"
                "1. Research the given topic on the internet. Your research should cover:\n"
                "- What the topic is (definition and purpose).\n"
                "- Key points, concepts, or relevant aspects.\n"
                "- Relevant data, updated statistics, or trustworthy studies that support the content.\n"
                "2. Write an email in HTML format, with:\n"
                "- A professional, clear, and objective tone.\n"
                "- A well-organized structure (title, introduction, main topics, and conclusion).\n"
                "- Enough information for the recipient to understand the topic and reflect on potential actions or strategies.\n"
                "3. Finally, send the email using the send_email tool.\n\n"
                "Remember: the goal is to inform and encourage productive discussions about the topic. The content must be reliable, direct, and "
                "relevant for decision-making.\n\n"
                "Informations:\n"
                "- Boss's name: {boss_name}\n"
                "- Boss email: {boss_email}\n"
                "- My name: {user_name}"
            ),
            expected_output=(
                "A clear, well-structured HTML email report covering the topic's definition, key points, relevant data or studies, written in "
                "a professional and objective tone, enabling informed reflection and decision-making."
            ),
            agent=report_agent
        )
        
        crew = Crew(
            agents=[report_agent],
            tasks=[report],
            verbose=True,
            process=Process.sequential 
        )

        return crew

from mcp_client import get_mcp_servers
from crewai_tools import MCPServerAdapter
from report_agent import ReportAgent
from dotenv import load_dotenv

load_dotenv()


def main():
    mcp_servers = get_mcp_servers()

    with MCPServerAdapter(mcp_servers) as tools:
        report_agent = ReportAgent(tools)

        crew = report_agent.create_crew()

        results = crew.kickoff(
            inputs={
                "user_input":"The topic is Agent2Agent protocol.",
                "boss_name": "Martin",
                "boss_email": "e***i@gmail.com",
                "user_name": "Edvaldo Melo"
            }
        )
        
        print(results.raw)


if __name__ == "__main__":
    main()

from mcp import StdioServerParameters
from dotenv import load_dotenv
import os

load_dotenv()

SMITHERY_KEY = os.getenv("SMITHERY_KEY")
SMITHERY_PROFILE = os.getenv("SMITHERY_PROFILE")


def get_mcp_servers():

    mcp_serper = StdioServerParameters(
        command="npx",
        args=[
            "-y",
            "@smithery/cli@latest",
            "run",
            "@marcopesani/mcp-server-serper",
            "--key",
            SMITHERY_KEY,
            "--profile",
            SMITHERY_PROFILE
        ]
    )

    mcp_send_email = {
        "transport": "sse",
        "url": "http://localhost:4000/sse/"
    }

    mcp_servers = [mcp_serper, mcp_send_email]

    return mcp_servers

from smolagents import CodeAgent, OpenAIServerModel


class ReportAgent:

    def __init__(self, tools):

        self.__tools = tools


    def run(self, user_input:str, boss_name:str, boss_email:str, user_name:str):

        prompt = (
            "You are responsible for sending an informative email to my boss containing a clear and well-researched report on a specified topic.\n\n"
            "Instructions:\n"
            "1. Research the given topic on the internet. Your research should cover:\n"
            "- What the topic is (definition and purpose).\n"
            "- Key points, concepts, or relevant aspects.\n"
            "- Relevant data, updated statistics, or trustworthy studies that support the content.\n"
            "2. Write an email in HTML format, with:\n"
            "- A professional, clear, and objective tone.\n"
            "- A well-organized structure (title, introduction, main topics, and conclusion).\n"
            "- Enough information for the recipient to understand the topic and reflect on potential actions or strategies.\n"
            "3. Finally, send the email using the send_email tool.\n\n"
            "Remember: the goal is to inform and encourage productive discussions about the topic. The content must be reliable, direct, and "
            "relevant for decision-making."
        )

        model = OpenAIServerModel(
            model_id="gpt-4o",
            temperature=0.1
        )

        agent = CodeAgent(
            model=model,
            max_steps=10,
            tools=self.__tools,
            verbosity_level=2
        )

        result = agent.run(
            task=prompt,
            additional_args={
                "user_input": user_input,
                "boss_name": boss_name,
                "boss_email": boss_email,
                "user_name": user_name
            }
        )
        
        return result

import asyncio
from mcp_client import get_mcp_servers
from smolagents import ToolCollection
from report_agent import ReportAgent
from dotenv import load_dotenv

load_dotenv()


async def main():
    mcp_servers = get_mcp_servers()

    with ToolCollection.from_mcp(mcp_servers, trust_remote_code=True) as tool_collection:
        tools = [*tool_collection.tools]

        report_agent = ReportAgent(tools)
        
        result = report_agent.run(
            user_input="What is the Agent2Agent protocol?",
            boss_name="Martin",
            boss_email="e***i@gmail.com",
            user_name="Edvaldo Melo"
        )
        print(result)


if __name__ == "__main__":
    asyncio.run(main())