adk-model

LLM model integrations for Rust Agent Development Kit (ADK-Rust) with Gemini, OpenAI, Anthropic, and DeepSeek.

Overview

adk-model provides LLM integrations for the Rust Agent Development Kit (ADK-Rust). Supports all major providers:

• Gemini - Google's Gemini models (3.0 Pro, 2.5 Pro, 2.0 Flash, etc.)
• OpenAI - GPT-5.2, GPT-5.1, GPT-5, GPT-4o, GPT-4o-mini, Azure OpenAI
• Anthropic - Claude Opus 4.5, Claude Sonnet 4.5, Claude Sonnet 4, Claude 3.5
• DeepSeek - DeepSeek-Chat, DeepSeek-Reasoner with thinking mode
• Groq - Ultra-fast inference (LLaMA 3.3, Mixtral, Gemma)
• Ollama - Local LLMs (LLaMA, Mistral, Qwen, Gemma, etc.)
• Streaming - Real-time response streaming for all providers
• Multimodal - Text, images, audio, video, and PDF input

The crate implements the Llm trait from adk-core, allowing models to be used interchangeably.

Installation

[dependencies]
adk-model = "0.1.9"

Or use the meta-crate:

[dependencies]
adk-rust = { version = "0.1.9", features = ["models"] }

Quick Start

Gemini (Google)

use adk_model::GeminiModel;
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.5-flash")?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

OpenAI

use adk_model::openai::{OpenAIClient, OpenAIConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("OPENAI_API_KEY")?;
    let model = OpenAIClient::new(OpenAIConfig::new(api_key, "gpt-4o"))?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

Anthropic (Claude)

use adk_model::anthropic::{AnthropicClient, AnthropicConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("ANTHROPIC_API_KEY")?;
    let model = AnthropicClient::new(AnthropicConfig::new(api_key, "claude-sonnet-4-20250514"))?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

DeepSeek

use adk_model::deepseek::{DeepSeekClient, DeepSeekConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("DEEPSEEK_API_KEY")?;

    // Standard chat model
    let model = DeepSeekClient::new(DeepSeekConfig::chat(api_key))?;

    // Or use the reasoner model with chain-of-thought
    // let model = DeepSeekClient::new(DeepSeekConfig::reasoner(api_key))?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

Groq (Ultra-Fast)

use adk_model::groq::{GroqClient, GroqConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = std::env::var("GROQ_API_KEY")?;
    let model = GroqClient::new(GroqConfig::llama70b(api_key))?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

Ollama (Local)

use adk_model::ollama::{OllamaModel, OllamaConfig};
use adk_agent::LlmAgentBuilder;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Requires: ollama serve && ollama pull llama3.2
    let model = OllamaModel::new(OllamaConfig::new("llama3.2"))?;

    let agent = LlmAgentBuilder::new("assistant")
        .model(Arc::new(model))
        .build()?;

    Ok(())
}

Supported Models

Google Gemini

See Gemini models documentation for the full list.

OpenAI

See OpenAI models documentation for the full list.

Anthropic Claude

See Anthropic models documentation for the full list.

DeepSeek

Features:

• Thinking Mode - Chain-of-thought reasoning with <thinking> tags
• Context Caching - Automatic KV cache for repeated prefixes (10x cost reduction)
• Tool Calling - Full function calling support

See DeepSeek API documentation for the full list.

Groq

Features:

• Ultra-Fast - LPU-based inference (fastest in the industry)
• Tool Calling - Full function calling support
• Large Context - Up to 128K tokens

See Groq documentation for the full list.

Ollama (Local)

Features:

• Local Inference - No API key required
• Privacy - Data stays on your machine
• Tool Calling - Full function calling support (uses non-streaming for reliability)
• MCP Integration - Connect to MCP servers for external tools

See Ollama library for all available models.

Features

• Streaming - Real-time response streaming for all providers
• Tool Calling - Function calling support across all providers
• Async - Full async/await support with backpressure
• Retry - Automatic retry with exponential backoff
• Generation Config - Temperature, top_p, top_k, max_tokens

Environment Variables

# Google Gemini
GOOGLE_API_KEY=your-google-api-key

# OpenAI
OPENAI_API_KEY=your-openai-api-key

# Anthropic
ANTHROPIC_API_KEY=your-anthropic-api-key

# DeepSeek
DEEPSEEK_API_KEY=your-deepseek-api-key

# Groq
GROQ_API_KEY=your-groq-api-key

# Ollama (no key needed, just start the server)
# ollama serve

Feature Flags

Enable specific providers with feature flags:

[dependencies]
# All providers (default)
adk-model = { version = "0.1.9", features = ["all-providers"] }

# Individual providers
adk-model = { version = "0.1.9", features = ["gemini"] }
adk-model = { version = "0.1.9", features = ["openai"] }
adk-model = { version = "0.1.9", features = ["anthropic"] }
adk-model = { version = "0.1.9", features = ["deepseek"] }
adk-model = { version = "0.1.9", features = ["groq"] }
adk-model = { version = "0.1.9", features = ["ollama"] }

Related Crates

• adk-rust - Meta-crate with all components
• adk-core - Core Llm trait
• adk-agent - Agent implementations

License

Apache-2.0

Part of ADK-Rust

This crate is part of the ADK-Rust framework for building AI agents in Rust.