LLM Providers in 10xGraph - OpenAI, Gemini, Claude, DeepSeek, Ollama

"""Run the same ReactAgent on every supported model provider.

CONFIGS maps a name to the ReactAgent arguments that select a model and backend. Nothing is
created until you pick one, so you only need the SDK and key for the provider you run.

Run: python examples/providers/providers.py [name]   (default: openai; see CONFIGS)
"""

import asyncio
import os
import sys

from dotenv import load_dotenv

from tenxgraph.core.state import Message
from tenxgraph.prebuilt.agent import ReactAgent


load_dotenv()


def get_weather(location: str) -> str:
    """Get the current weather for a location."""
    return f"The weather in {location} is sunny, 22C."


# The provider is detected from the model string, so no provider= argument is needed.
# Anything else is an ordinary keyword argument for ReactAgent / Agent.
CONFIGS: dict[str, dict] = {
    # --- OpenAI: pip install "10xgraph[openai]", OPENAI_API_KEY ---
    "openai": {"model": "gpt-5-mini"},  # Responses API (the default)
    "openai-responses": {"model": "gpt-5-mini", "api_style": "responses"},  # Responses API, explicit
    # --- Google: pip install "10xgraph[google-genai]", GEMINI_API_KEY ---
    "gemini": {"model": "gemini-2.5-flash"},
    # Same model on Vertex AI. Needs GOOGLE_CLOUD_PROJECT (+ optional GOOGLE_CLOUD_LOCATION)
    # and application default credentials instead of an API key.
    "gemini-vertex": {"model": "gemini-2.5-flash", "use_vertex_ai": True},
    # --- Anthropic: pip install "10xgraph[anthropic]", ANTHROPIC_API_KEY ---
    "claude": {"model": "claude-sonnet-5-5"},
    # Claude through Google Vertex AI: "10xgraph[anthropic-vertex]". The SDK reads the
    # project and region from its own env vars (ANTHROPIC_VERTEX_PROJECT_ID, CLOUD_ML_REGION).
    "claude-vertex": {"model": "claude-sonnet-5-5", "anthropic_backend": "vertex"},
    # Claude through Amazon Bedrock: "10xgraph[anthropic-bedrock]", AWS credentials/region
    # from the environment. The Bedrock model id keeps its "anthropic." prefix.
    "claude-bedrock": {"model": "anthropic.claude-sonnet-5-5", "anthropic_backend": "bedrock"},
    # --- OpenAI-compatible servers: unknown model names use the OpenAI client + base_url ---
    # reasoning_config=None because these models do not take OpenAI reasoning options.
    "deepseek": {
        "model": "deepseek-chat",
        "base_url": "https://api.deepseek.com",
        "api_key": os.getenv("DEEPSEEK_API_KEY"),
        "reasoning_config": None,
    },
    # Local model served by Ollama (`ollama pull llama3.1`); the key is ignored but required.
    "ollama": {
        "model": "llama3.1",
        "base_url": "http://localhost:11434/v1",
        "api_key": "ollama",
        "reasoning_config": None,
    },
}


async def main() -> None:
    name = sys.argv[1] if len(sys.argv) > 1 else "openai"
    if name not in CONFIGS:
        raise SystemExit(f"Unknown provider '{name}'. Choose from: {', '.join(CONFIGS)}")

    agent = ReactAgent(
        **CONFIGS[name],
        system_prompt=[{"role": "system", "content": "You are a helpful assistant."}],
        tools=[get_weather],
    )
    app = agent.compile()

    print(f"provider config: {name} -> model {CONFIGS[name]['model']}")
    result = await app.ainvoke(
        {"messages": [Message.text_message("What is the weather in Paris?")]},
        config={"thread_id": f"providers-{name}"},
    )
    print("assistant:", result["messages"][-1].text())
    await app.aclose()


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

"""Turn on model reasoning per provider and read the reasoning back from the reply.

reasoning_config is one dict for all providers; each provider uses the keys it understands.
Run: python examples/providers/reasoning.py [openai|gemini|claude]
"""

import asyncio
import sys

from dotenv import load_dotenv

from tenxgraph.core.state import Message
from tenxgraph.core.state.message_block import ReasoningBlock
from tenxgraph.prebuilt.agent import ReactAgent


load_dotenv()

REASONING: dict[str, dict] = {
    # effort goes to the model; summary asks OpenAI for a readable reasoning summary.
    "openai": {
        "model": "gpt-5-mini",
        "api_style": "responses",  # reasoning summaries come from the Responses API
        "reasoning_config": {"effort": "low", "summary": "auto"},
    },
    # thinking_budget is an exact token budget and overrides effort. Without it, effort maps
    # to a budget: low=512, medium=8192, high=24576. include_thoughts is set for you.
    "gemini": {
        "model": "gemini-2.5-flash",
        "reasoning_config": {"thinking_budget": 2048},
    },
    # For current Claude models effort selects adaptive thinking depth. A token budget is
    # not supported and is ignored with a warning.
    "claude": {
        "model": "claude-sonnet-5-5",
        "reasoning_config": {"effort": "medium"},
    },
}


async def main() -> None:
    name = sys.argv[1] if len(sys.argv) > 1 else "gemini"
    agent = ReactAgent(**REASONING[name])
    app = agent.compile()

    question = "A bat and a ball cost 1.10. The bat costs 1.00 more than the ball. Ball price?"
    result = await app.ainvoke(
        {"messages": [Message.text_message(question)]},
        config={"thread_id": f"reasoning-{name}"},
    )
    reply = result["messages"][-1]

    # Reasoning arrives as ReasoningBlock entries next to the TextBlock in reply.content.
    for block in reply.content:
        if isinstance(block, ReasoningBlock):
            print("reasoning:", block.summary[:300])
    print("answer:", reply.text())
    print("reasoning tokens:", reply.usages.reasoning_tokens if reply.usages else 0)
    await app.aclose()


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

"""Call a provider SDK yourself inside a node and return a Message through a converter.

Use this when you need an SDK feature the Agent class does not expose. The converter turns
the raw SDK response (text, tool calls, usage) into the Message the graph expects.
Run: python examples/providers/custom_converter.py [gemini|openai]
"""

import asyncio
import os
import sys

from dotenv import load_dotenv

from tenxgraph.core.graph import StateGraph
from tenxgraph.core.state import AgentState, Message
from tenxgraph.runtime.adapters.llm import GoogleGenAIConverter, OpenAIConverter
from tenxgraph.utils.constants import END, START


load_dotenv()


async def gemini_node(state: AgentState, config: dict) -> Message:
    from google import genai

    client = genai.Client(api_key=os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY"))
    prompt = state.context[-1].text()
    response = await client.aio.models.generate_content(model="gemini-2.5-flash", contents=prompt)
    return await GoogleGenAIConverter().convert_response(response)


async def openai_node(state: AgentState, config: dict) -> Message:
    from openai import AsyncOpenAI

    client = AsyncOpenAI()
    response = await client.chat.completions.create(
        model="gpt-5-mini",
        messages=[{"role": "user", "content": state.context[-1].text()}],
    )
    return await OpenAIConverter().convert_response(response)


NODES = {"gemini": gemini_node, "openai": openai_node}


async def main() -> None:
    name = sys.argv[1] if len(sys.argv) > 1 else "gemini"

    graph = StateGraph()
    graph.add_node("MAIN", NODES[name])
    graph.add_edge(START, "MAIN")
    graph.add_edge("MAIN", END)
    app = graph.compile()

    result = await app.ainvoke(
        {"messages": [Message.text_message("Write a haiku about Python.")]},
        config={"thread_id": "custom-converter"},
    )
    reply = result["messages"][-1]
    print("assistant:", reply.text())
    print("usage:", reply.usages)
    await app.aclose()


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