from langchain_core.tools import tool

# ❌ Descrições vagas — LLM confunde
@tool
def find_word_meaning(word: str) -> str:
    """Search for information about a word."""
    # (implementação simplificada)
    return f"Definition of {word}: ..."

@tool
def find_word_rhymes(word: str) -> str:
    """Search for information about a word."""
    # (implementação simplificada)
    return f"Rhymes of {word}: ..."

# Teste: "What does 'serendipity' mean?"
# Possível erro: LLM escolhe find_word_rhymes em vez de find_word_meaning

# ✅ Descrições específicas
@tool
def find_word_meaning(word: str) -> str:
    """Look up the definition and meaning of a word in a dictionary.
    Use when the user asks 'what does X mean' or 'definition of X'.
    """
    return f"Definition of {word}: ..."

@tool
def find_word_rhymes(word: str) -> str:
    """Find words that rhyme with a given word.
    Use when the user asks for rhymes, similar-sounding words, or poetry help.
    """
    return f"Rhymes of {word}: ..."

@tool
def calculate(a: float, b: float, operation: str) -> float:
    """Performs a mathematical operation between two numbers.
    Use when you need to perform numeric calculations like addition,
    subtraction, multiplication, or division.
    Args:
        a: First number
        b: Second number
        operation: One of 'add', 'subtract', 'multiply', 'divide'
    """
    ops = {'add': a+b, 'subtract': a-b,
           'multiply': a*b, 'divide': a/b}
    return ops[operation]

@tool
def get_time() -> str:
    """Returns the current date and time.
    Use when the user asks about the current time, today's date,
    or 'what time is it'.
    """
    from datetime import datetime
    return datetime.now().strftime("%d/%m/%Y %H:%M:%S")

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Reverse")

@mcp.tool()
def reverse_string(text: str) -> str:
    """Reverses a string. Use when the user wants to flip or reverse text."""
    return text[::-1]

if __name__ == "__main__":
    mcp.run(transport="stdio")

import subprocess
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gemma4:e2b-it-qat",
    base_url="http://localhost:11434/v1",
    api_key="ollama",
    temperature=0,
)

server_params = StdioServerParameters(
    command="python",
    args=["reverse_server.py"],
)

async with stdio_client(
    server_params, errlog=subprocess.DEVNULL) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await load_mcp_tools(session)
        agente = create_agent(llm, tools)
        resultado = await agente.ainvoke(
            {"messages": "Reverse the word 'Guilda'"}
        )
        print(resultado["messages"][-1].content)
        # "The reverse of 'Guilda' is 'adliuG'."

import subprocess
from contextlib import AsyncExitStack
from langchain_core.tools import tool
from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from langchain_mcp_adapters.tools import load_mcp_tools

llm = ChatOpenAI(
    model="gemma4:e2b-it-qat",
    base_url="http://localhost:11434/v1",
    api_key="ollama",
    temperature=0,
)

# Suas ferramentas @tool
@tool
def calculate(a: float, b: float, operation: str) -> float:
    """Performs a mathematical operation between two numbers.
    Args:
        a: First number
        b: Second number
        operation: One of 'add', 'subtract', 'multiply', 'divide'
    """
    ops = {'add': a+b, 'subtract': a-b,
           'multiply': a*b, 'divide': a/b}
    return ops[operation]

# Ferramentas MCP (servidor do início da apostila)
SERVIDORES = [
    StdioServerParameters(command="python", args=["math_server.py"]),
]

async with AsyncExitStack() as stack:
    mcp_tools = []
    for params in SERVIDORES:
        read, write = await stack.enter_async_context(
            stdio_client(params, errlog=subprocess.DEVNULL))
        session = await stack.enter_async_context(ClientSession(read, write))
        await session.initialize()
        mcp_tools.extend(await load_mcp_tools(session))

    # Combina tudo
    all_tools = [calculate] + mcp_tools
    agente = create_agent(llm, all_tools)

    resultado = await agente.ainvoke(
        {"messages": "Quanto é 10 + 5 multiplicado por 3?"}
    )
    print(resultado["messages"][-1].content)