LLM Support

OPENAI_API_KEY=your_openai_api_key
OPENAI_BASE_URL=https://api.openai.com/v1  # Optional

ANTHROPIC_API_KEY=your_anthropic_api_key

# For Gemini API
GOOGLE_API_KEY=your_google_api_key
# OR (legacy)
GEMINI_API_KEY=your_gemini_api_key

# For Vertex AI
GOOGLE_CLOUD_PROJECT=your_project_id
GOOGLE_CLOUD_LOCATION=us-central1  # Optional

GROQ_API_KEY=your_groq_api_key
GROQ_BASE_URL=https://api.groq.com  # Optional

CO_API_KEY=your_cohere_api_key
CO_BASE_URL=https://api.cohere.ai  # Optional

MISTRAL_API_KEY=your_mistral_api_key

HF_TOKEN=your_huggingface_token

GROK_API_KEY=your_grok_api_key

AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/
AZURE_OPENAI_API_KEY=your_azure_api_key
OPENAI_API_VERSION=2024-02-15-preview

class Model(ABC):
    def __init__(
        self,
        *,
        settings: ModelSettings | None = None,
        profile: ModelProfileSpec | None = None,
    ) -> None:
        """Initialize the model with optional settings and profile.

        Args:
            settings: Model-specific settings that will be used as defaults for this model.
            profile: The model profile to use.
        """

class ModelSettings(TypedDict, total=False):
    max_tokens: int
    """The maximum number of tokens to generate before stopping."""
    
    temperature: float
    """Amount of randomness injected into the response."""
    
    top_p: float
    """An alternative to sampling with temperature, called nucleus sampling."""
    
    timeout: float | Timeout
    """Override the client-level default timeout for a request, in seconds."""
    
    parallel_tool_calls: bool
    """Whether to allow parallel tool calls."""
    
    seed: int
    """The random seed to use for the model, theoretically allowing for deterministic results."""
    
    presence_penalty: float
    """Penalize new tokens based on whether they have appeared in the text so far."""
    
    frequency_penalty: float
    """Penalize new tokens based on their existing frequency in the text so far."""
    
    logit_bias: dict[str, int]
    """Modify the likelihood of specified tokens appearing in the completion."""
    
    stop_sequences: list[str]
    """Sequences that will cause the model to stop generating."""
    
    extra_headers: dict[str, str]
    """Extra headers to send to the model."""
    
    extra_body: object
    """Extra body to send to the model."""

class AnthropicModelSettings(ModelSettings, total=False):
    anthropic_metadata: BetaMetadataParam
    """An object describing metadata about the request.
    
    Contains `user_id`, an external identifier for the user who is associated with the request.
    """
    
    anthropic_thinking: BetaThinkingConfigParam
    """Determine whether the model should generate a thinking block.
    
    See [the Anthropic docs](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking) for more information.
    """

class OpenAIChatModelSettings(ModelSettings, total=False):
    openai_reasoning_effort: ReasoningEffort
    """Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning).
    
    Currently supported values are `low`, `medium`, and `high`.
    """
    
    openai_logprobs: bool
    """Include log probabilities in the response."""
    
    openai_top_logprobs: int
    """Include log probabilities of the top n tokens in the response."""
    
    openai_user: str
    """A unique identifier representing the end-user, which can help OpenAI monitor and detect abuse."""
    
    openai_service_tier: Literal['auto', 'default', 'flex', 'priority']
    """The service tier to use for the model request."""
    
    openai_prediction: ChatCompletionPredictionContentParam
    """Enables [predictive outputs](https://platform.openai.com/docs/guides/predicted-outputs)."""

class GoogleModelSettings(ModelSettings, total=False):
    google_safety_settings: list[SafetySettingDict]
    """The safety settings to use for the model.
    
    See <https://ai.google.dev/gemini-api/docs/safety-settings> for more information.
    """
    
    google_thinking_config: ThinkingConfigDict
    """The thinking configuration to use for the model.
    
    See <https://ai.google.dev/gemini-api/docs/thinking> for more information.
    """
    
    google_labels: dict[str, str]
    """User-defined metadata to break down billed charges. Only supported by the Vertex AI API."""
    
    google_video_resolution: MediaResolution
    """The video resolution to use for the model."""
    
    google_cached_content: str
    """The name of the cached content to use for the model."""

class GroqModelSettings(ModelSettings, total=False):
    groq_reasoning_format: Literal['hidden', 'raw', 'parsed']
    """Controls how reasoning output is formatted."""

class BedrockModelSettings(ModelSettings, total=False):
    bedrock_guardrail_config: GuardrailConfigurationTypeDef
    """Content moderation and safety settings for Bedrock API requests."""
    
    bedrock_performance_configuration: PerformanceConfigurationTypeDef
    """Performance optimization settings for model inference."""
    
    bedrock_request_metadata: dict[str, str]
    """Additional metadata to attach to Bedrock API requests."""
    
    bedrock_additional_model_response_fields_paths: list[str]
    """JSON paths to extract additional fields from model responses."""
    
    bedrock_prompt_variables: Mapping[str, PromptVariableValuesTypeDef]
    """Variables for substitution into prompt templates."""
    
    bedrock_additional_model_requests_fields: Mapping[str, Any]
    """Additional model-specific parameters to include in requests."""

from upsonic.models.anthropic import AnthropicModel, AnthropicModelSettings
from upsonic.profiles import ModelProfile

# Create custom settings
settings = AnthropicModelSettings(
    max_tokens=2048,
    temperature=0.7,
    anthropic_thinking={
        "type": "enabled",
        "budget_tokens": 4096
    }
)

# Create custom profile
profile = ModelProfile(
    supports_tools=True,
    supports_json_schema_output=True,
    default_structured_output_mode='tool'
)

# Create model instance
model = AnthropicModel(
    model_name="claude-3-5-sonnet-20241022",
    settings=settings,
    profile=profile
)

# Create agent with the model
from upsonic import Agent
agent = Agent(model=model)

from upsonic import Agent
from upsonic.models.openai import OpenAIResponsesModelSettings
from upsonic.profiles import OpenAIModelProfile

# Create settings
settings = OpenAIResponsesModelSettings(
    max_tokens=1024,
    temperature=0.5,
    openai_reasoning_effort="high",
    openai_reasoning_summary="detailed"
)

# Create profile
profile = OpenAIModelProfile(
    supports_tools=True,
    supports_json_object_output=True,
    openai_chat_supports_web_search=True,
    openai_supports_sampling_settings=True
)

# Create agent with model, settings, and profile
agent = Agent(
    model="openai/gpt-4o",
    settings=settings,
    profile=profile
)

from upsonic.models.google import GoogleModel, GoogleModelSettings

# Create Google-specific settings
settings = GoogleModelSettings(
    max_tokens=1500,
    temperature=0.3,
    google_thinking_config={
        "include_thoughts": True,
        "thinking_budget": 2048
    },
    google_safety_settings=[
        {
            "category": "HARM_CATEGORY_HARASSMENT",
            "threshold": "BLOCK_MEDIUM_AND_ABOVE"
        }
    ]
)

# Create model
model = GoogleModel(
    model_name="gemini-2.5-flash-lite",
    settings=settings
)

# Create agent
from upsonic import Agent
agent = Agent(model=model)

from upsonic import Agent, Task
from upsonic.models.anthropic import AnthropicModel, AnthropicModelSettings

# Configure thinking for complex problem solving
settings = AnthropicModelSettings(
    max_tokens=4096,
    temperature=0.1,
    anthropic_thinking={
        "type": "enabled",
        "budget_tokens": 8192
    }
)

model = AnthropicModel(
    model_name="claude-3-5-sonnet-20241022",
    settings=settings
)

agent = Agent(
    model=model,
    enable_thinking_tool=True  # Enable framework-level thinking
)

task = Task("Solve this complex mathematical proof step by step")
result = agent.do(task)

from upsonic import Agent, Task
from upsonic.models.openai import OpenAIResponsesModel, OpenAIResponsesModelSettings

settings = OpenAIResponsesModelSettings(
    max_tokens=2048,
    temperature=0.2,
    openai_reasoning_effort="high",
    openai_reasoning_summary="detailed"
)

model = OpenAIResponsesModel(
    model_name="o1-preview",
    settings=settings
)

agent = Agent(model=model)

task = Task("Analyze this complex business strategy and provide detailed reasoning")
result = agent.do(task)

from upsonic import Agent, Task
from upsonic.models.google import GoogleModel, GoogleModelSettings

settings = GoogleModelSettings(
    max_tokens=1500,
    temperature=0.4,
    google_thinking_config={
        "include_thoughts": True,
        "thinking_budget": -1  # Automatic budget
    }
)

model = GoogleModel(
    model_name="gemini-2.5-flash-lite",
    settings=settings
)

agent = Agent(model=model)

task = Task("Explain quantum computing concepts with detailed reasoning")
result = agent.do(task)

from upsonic import Agent, Task
from upsonic.models.groq import GroqModel, GroqModelSettings

settings = GroqModelSettings(
    max_tokens=1024,
    temperature=0.6,
    groq_reasoning_format="parsed"  # Show parsed reasoning
)

model = GroqModel(
    model_name="llama-3.3-70b-versatile",
    settings=settings
)

agent = Agent(model=model)

task = Task("Write a creative story with reasoning")
result = agent.do(task)