# Traditional approach: ALL tools loaded every time
agent = PolyAgent(
    mcp_servers=[
        "http://localhost:8000/mcp",  # 20 tools
        "http://localhost:8001/mcp",  # 30 tools  
        "http://localhost:8002/mcp",  # 25 tools
        # ... 10 servers = 200 tools total
    ]
)
# Every request: 200 tools × 250 tokens = 50,000 tokens wasted!

from polymcp.polyagent import UnifiedPolyAgent, OpenAIProvider

# Skills load tools on-demand based on query semantics
agent = UnifiedPolyAgent(
    llm_provider=OpenAIProvider(),
    skills_dir="/mnt/skills",  # Auto-loads relevant skills
    mcp_servers=["http://localhost:8000/mcp"]
)

# Query: "Send email to John"
# Only loads: email skill (5 tools) instead of ALL 200 tools!
result = agent.run("Send email to John about project updates")

from polymcp import SkillGenerator

# Auto-generate skill from existing MCP server
generator = SkillGenerator()
generator.generate_from_mcp(
    server_url="http://localhost:8000/mcp",
    output_path="/mnt/skills/github/SKILL.md",
    skill_name="GitHub Operations"
)

# Skill file created automatically with:
# - Tool descriptions and schemas
# - Usage examples and best practices
# - Semantic category tags

from polymcp import expose_tools_stdio

def calculate(a: int, b: int, operation: str = "add") -> float:
    """Perform mathematical operations."""
    ops = {"add": a + b, "multiply": a * b, "divide": a / b}
    return ops.get(operation, a + b)

def analyze_text(text: str) -> dict:
    """Analyze text and return statistics."""
    return {
        "characters": len(text),
        "words": len(text.split()),
        "sentences": text.count('.') + text.count('!')
    }

# Create stdio server (JSON-RPC 2.0 compliant)
server = expose_tools_stdio(
    tools=[calculate, analyze_text],
    server_name="Math & Text Tools",
    server_version="1.0.0"
)

# Run server
if __name__ == "__main__":
    server.run()

from polymcp import expose_tools_wasm
import math

def calculate_stats(numbers: list) -> dict:
    """Calculate statistics for a list of numbers."""
    mean = sum(numbers) / len(numbers)
    variance = sum((x - mean) ** 2 for x in numbers) / len(numbers)
    return {
        "mean": round(mean, 2),
        "std": round(math.sqrt(variance), 2),
        "min": min(numbers),
        "max": max(numbers)
    }

def prime_factors(n: int) -> dict:
    """Find prime factors of a number."""
    factors = []
    d = 2
    while d * d <= n:
        while n % d == 0:
            factors.append(d)
            n //= d
        d += 1
    if n > 1:
        factors.append(n)
    return {"factors": factors, "is_prime": len(factors) == 1}

# Compile to WASM bundle
compiler = expose_tools_wasm(
    tools=[calculate_stats, prime_factors],
    server_name="Math Tools",
    server_version="1.0.0"
)

bundle = compiler.compile(output_dir="./dist")

# Generates:
# dist/
# ├── tools_bundle.py     # Python source
# ├── loader.js           # JavaScript loader
# ├── demo.html           # Interactive demo (minimal design)
# ├── package.json        # npm package
# └── README.md           # Deployment guide

from polymcp.polymcp_toolkit import expose_tools_http
from polymcp.polymcp_toolkit.mcp_auth import ProductionAuthenticator, add_production_auth_to_mcp

# Server with authentication
def add(a: int, b: int) -> int:
    return a + b

app = expose_tools_http(tools=[add])
auth = ProductionAuthenticator(enforce_https=False)  # Use True in production
app = add_production_auth_to_mcp(app, auth)

# Run: uvicorn script:app

from polymcp.polyagent import UnifiedPolyAgent, OllamaProvider

agent = UnifiedPolyAgent(
    llm_provider=OllamaProvider(model="llama3.2"),
    mcp_servers=["http://localhost:8000"],
    http_headers={"X-API-Key": "sk-your-api-key-from-db"}
)

# Make authenticated requests
result = await agent.run_async("Add 42 and 58")

from polymcp.polyagent import CodeModeAgent, PolyAgent, OllamaProvider, OpenAIProvider

agent = CodeModeAgent(
    llm_provider=OpenAIProvider(),
    mcp_servers=["http://localhost:8000/mcp"]
)

# Single code generation orchestrates all tools
result = agent.run("""
    Record these 3 expenses:
    - Rent: $2500
    - Utilities: $150  
    - Food: $300
    Then calculate total and generate financial summary
""")

from polymcp.polymcp_toolkit import expose_tools_http

app = expose_tools_http(
    tools=[my_function],
    title="My MCP Server"
)
# Run with uvicorn - great for microservices

from polymcp.polymcp_toolkit import expose_tools_inprocess

server = expose_tools_inprocess(tools=[my_function])
result = await server.invoke("my_function", {"param": "value"})
# 🚀 Direct calls, no network, perfect for embedded agents

from polymcp.polyagent import UnifiedPolyAgent, OllamaProvider

agent = UnifiedPolyAgent(
    llm_provider=OllamaProvider(model="gpt-oss:120b-cloud"),
    mcp_servers=["http://localhost:8000/mcp"],
    stdio_servers=[{
        "command": "npx",
        "args": ["@playwright/mcp@latest"]
    }],
    memory_enabled=True  # 🆕 Persistent memory across requests
)

# Agent autonomously plans and executes multi-step tasks
response = await agent.run_async("""
    Go to github.com/llm-use/polymcp,
    take a screenshot,
    analyze the README,
    and summarize the key features
""")

agent = UnifiedPolyAgent(
    llm_provider=llm,
    mcp_servers=[
        "http://localhost:8000/mcp",  # Your custom tools
        "http://localhost:8001/mcp",  # Advanced tools
    ],
    stdio_servers=[
        {
            "command": "npx",
            "args": ["@playwright/mcp@latest"]  # Browser automation
        }
    ]
)

from polymcp.polymcp_toolkit.expose import expose_tools

def greet(name: str) -> str:
    """Greet a person."""
    return f"Hello, {name}!"

def add_numbers(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

# Expose the functions as MCP tools
app = expose_tools(greet, add_numbers)

# Run the server with:
# uvicorn my_mcp_server:app --reload

from polymcp.polyagent.agent import PolyAgent
from polymcp.polyagent.llm_providers import OllamaProvider

agent = PolyAgent(
    llm_provider=OllamaProvider(model="gpt-oss:120b-cloud"),
    mcp_servers=["http://localhost:8000/mcp"],
    verbose=True
)

response = agent.run("What is the sum of 5 and 10?")
print(response)

from polymcp.polyagent.unified_agent import UnifiedPolyAgent
from polymcp.polyagent.llm_providers import OllamaProvider

agent = UnifiedPolyAgent(
    llm_provider=OllamaProvider(model="gpt-oss:120b-cloud"),
    stdio_servers=[{
        "command": "npx",
        "args": ["@playwright/mcp@latest"],
        "env": {"DISPLAY": ":1"}  # Optional for headless mode
    }],
    verbose=True
)

response = agent.run("Open https://github.com/JustVugg/polymcp and summarize the README.")
print(response)