Crate xai_grpc_client 

xai-grpc-client

Unofficial Rust client for xAI’s Grok API with gRPC support.

Features

• Async/await API - Built on tokio and tonic
• Type-safe requests - Strongly typed request builders
• Streaming support - Real-time response streaming
• Tool calling - Function calling with 7 tool types
• Multimodal - Text and image inputs
• Advanced features - Log probabilities, reasoning traces, deferred completions
• Secure by default - Uses secrecy crate for API keys

Quick Start

use xai_grpc_client::{GrokClient, ChatRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client from GROK_API_KEY environment variable
    let mut client = GrokClient::from_env().await?;

    // Create a simple chat request
    let request = ChatRequest::new()
        .user_message("What is the meaning of life?")
        .with_model("grok-2-1212")
        .with_max_tokens(100);

    // Get response
    let response = client.complete_chat(request).await?;
    println!("{}", response.content);

    Ok(())
}

Streaming Example

use xai_grpc_client::{GrokClient, ChatRequest};
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GrokClient::from_env().await?;

    let request = ChatRequest::new()
        .user_message("Write a short poem");

    let mut stream = client.stream_chat(request).await?;

    while let Some(chunk) = stream.next().await {
        let chunk = chunk?;
        print!("{}", chunk.delta);
    }

    Ok(())
}

Tool Calling Example

use xai_grpc_client::{GrokClient, ChatRequest, FunctionTool, Tool, ToolChoice};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GrokClient::from_env().await?;

    let get_weather = FunctionTool::new(
        "get_weather",
        "Get the current weather in a location"
    )
    .with_parameters(json!({
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City name"
            }
        },
        "required": ["location"]
    }));

    let request = ChatRequest::new()
        .user_message("What's the weather in Tokyo?")
        .add_tool(Tool::Function(get_weather))
        .with_tool_choice(ToolChoice::Auto);

    let response = client.complete_chat(request).await?;

    if !response.tool_calls.is_empty() {
        println!("Tool called: {:?}", response.tool_calls[0]);
    }

    Ok(())
}

Re-exports

pub use api_key::ApiKeyInfo;

pub use client::GrokClient;

pub use client::GrokConfig;

pub use documents::DocumentSearchRequest;

pub use documents::DocumentSearchResponse;

pub use documents::RankingMetric;

pub use documents::SearchMatch;

pub use embedding::EmbedEncodingFormat;

pub use embedding::EmbedInput;

pub use embedding::EmbedRequest;

pub use embedding::EmbedResponse;

pub use embedding::Embedding;

pub use embedding::EmbeddingUsage;

pub use image::GeneratedImage;

pub use image::ImageFormat;

pub use image::ImageGenerationRequest;

pub use image::ImageGenerationResponse;

pub use models::EmbeddingModel;

pub use models::ImageGenerationModel;

pub use models::LanguageModel;

pub use models::Modality;

pub use request::ChatRequest;

pub use request::CompletionOptions;

pub use request::ContentPart;

pub use request::ImageDetail;

pub use request::Message;

pub use request::MessageContent;

pub use request::ReasoningEffort;

pub use request::ResponseFormat;

pub use request::SearchConfig;

pub use request::SearchMode;

pub use request::SearchSource;

pub use response::ChatChunk;

pub use response::ChatResponse;

pub use response::FinishReason;

pub use response::LogProb;

pub use response::LogProbs;

pub use response::TokenUsage;

pub use response::TopLogProb;

pub use sample::SampleChoice;

pub use sample::SampleRequest;

pub use sample::SampleResponse;

pub use tokenize::Token;

pub use tokenize::TokenizeRequest;

pub use tokenize::TokenizeResponse;

pub use tools::CollectionsSearchTool;

pub use tools::DocumentSearchTool;

pub use tools::FunctionCall;

pub use tools::FunctionTool;

pub use tools::McpTool;

pub use tools::Tool;

pub use tools::ToolCall;

pub use tools::ToolCallKind;

pub use tools::ToolCallStatusKind;

pub use tools::ToolChoice;

pub use tools::WebSearchTool;

pub use tools::XSearchTool;

Modules

api_key

API key information and status. API key information API

client

Client implementation for connecting to the xAI Grok API. Client implementation for the xAI Grok API.

documents

Documents search API for RAG. Documents search API for RAG (Retrieval-Augmented Generation)

embedding

Embedding API for vector representations. Embedding API for generating vector representations.

image

Image generation API. Image generation API

models

Model listing and information API. Model listing and information API.

prelude

Prelude module for convenient imports

request

Request types and builders for chat completions. Request types and builders for the Grok API.

response

Response types for chat completions. Response types for chat completions.

sample

Sample API for raw text sampling. Sample API for raw text sampling

tokenize

Tokenization API for counting tokens. Tokenization API for xAI’s Grok models

tools

Tool calling support (function calling, web search, etc.). Tool calling support for Grok API.

Structs

Certificate

Represents a X509 certificate.

Channel

A default batteries included transport channel.

ClientTlsConfig

Configures TLS settings for endpoints.

Endpoint

Channel builder.

Enums

GrokError

Errors that can occur when using the Grok API client.

IncludeOption

Type Aliases

Result

Result type alias using GrokError.