Package 'mLLMCelltype'

Description

A comprehensive function for automated cell type annotation using multiple Large Language Models (LLMs). This function supports both Seurat's differential gene expression results and custom gene lists as input. It implements a sophisticated annotation pipeline that leverages state-of-the-art LLMs to identify cell types based on marker gene expression patterns.

• A data frame from Seurat's FindAllMarkers() function containing differential gene expression results (must have columns: 'cluster', 'gene', and 'avg_log2FC'). The function will select the top genes based on avg_log2FC for each cluster.

• A list where each element has a 'genes' field containing marker genes for a cluster. This can be in one of these formats:

  • Named with cluster IDs: list("0" = list(genes = c(...)), "1" = list(genes = c(...)))

  • Named with cell type names: list(t_cells = list(genes = c(...)), b_cells = list(genes = c(...)))

  • Unnamed list: list(list(genes = c(...)), list(genes = c(...)))

• Cluster IDs are preserved as-is. The function does not modify or re-index cluster IDs. 'mouse brain'). This helps provide context for more accurate annotations.

• OpenAI: 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'

• Anthropic: 'claude-opus-4-7', 'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001'

• DeepSeek: 'deepseek-v4-flash', 'deepseek-v4-pro'

• Google: 'gemini-3.1-pro-preview', 'gemini-3-flash-preview', 'gemini-3.1-flash-lite'

• Alibaba: 'qwen3.6-max-preview', 'qwen3.6-plus', 'qwen3.6-flash'

• Stepfun: 'step-3.5-flash', 'step-3.5-flash-2603', 'step-3'

• Zhipu/Z.AI: 'glm-5.1', 'glm-5-turbo', 'glm-5'

• MiniMax: 'MiniMax-M2.7', 'MiniMax-M2.7-highspeed', 'MiniMax-M2.5'

• X.AI: 'grok-4.3', 'grok-4.3-latest', 'grok-latest'

• OpenRouter: Provides access to models from multiple providers through a single API. Format: 'provider/model-name'

  • OpenAI models: 'openai/gpt-5.5', 'openai/gpt-5.4-mini'

  • Anthropic models: 'anthropic/claude-opus-4.7', 'anthropic/claude-sonnet-4.6'

  • Google models: 'google/gemini-3.1-pro-preview', 'google/gemini-3-flash-preview'

  • X.AI models: 'x-ai/grok-4.3'

  • Stepfun models: 'stepfun/step-3.5-flash' Each provider requires a specific API key format and authentication method:

• OpenAI: "sk-..." (obtain from OpenAI platform)

• Anthropic: "sk-ant-..." (obtain from Anthropic console)

• Google: A Google API key for Gemini models (obtain from Google AI)

• DeepSeek: API key from DeepSeek platform

• Qwen: API key from Alibaba Cloud

• Stepfun: API key from Stepfun AI

• Zhipu: API key from Zhipu AI

• MiniMax: API key from MiniMax

• X.AI: API key for Grok models

• OpenRouter: "sk-or-..." (obtain from OpenRouter) OpenRouter provides access to multiple models through a single API key

The API key can be provided directly or stored in environment variables:

# Direct API key
result <- annotate_cell_types(input, tissue_name, model="gpt-5.5",
                             api_key="sk-...")

# Using environment variables
Sys.setenv(OPENAI_API_KEY="sk-...")
Sys.setenv(ANTHROPIC_API_KEY="sk-ant-...")
Sys.setenv(OPENROUTER_API_KEY="sk-or-...")

# Then use with environment variables
result <- annotate_cell_types(input, tissue_name, model="claude-sonnet-4-6",
                             api_key=Sys.getenv("ANTHROPIC_API_KEY"))

If NA, returns the generated prompt without making an API call, which is useful for reviewing the prompt before sending it to the API. when input is from Seurat's FindAllMarkers(). Default: 10

• A single character string: Applied to all providers (e.g., "https://api.proxy.com/v1")

• A named list: Provider-specific URLs (e.g., list(openai = "https://openai-proxy.com/v1", anthropic = "https://anthropic-proxy.com/v1")). This is useful for:

  • Users accessing international APIs through proxies

  • Enterprise users with internal API gateways

  • Development/testing with local or alternative endpoints If NULL (default), uses official API endpoints for each provider.

Usage

annotate_cell_types(
  input,
  tissue_name,
  model = "gpt-5.5",
  api_key = NA,
  top_gene_count = 10,
  debug = FALSE,
  base_urls = NULL,
  return_reasoning = FALSE
)

Arguments

Value

When api_key is provided and return_reasoning is FALSE, the provider response split by newline as a character vector. When return_reasoning is TRUE, a named list where each element is a list with cell_type, marker_genes, and gene_expression. When api_key is NA, the generated prompt string.

See Also

• Seurat::FindAllMarkers()

• get_provider()

Examples

# Example 1: Using custom gene lists, returning prompt only (no API call)
annotate_cell_types(
  input = list(
    t_cells = list(genes = c('CD3D', 'CD3E', 'CD3G', 'CD28')),
    b_cells = list(genes = c('CD19', 'CD79A', 'CD79B', 'MS4A1')),
    monocytes = list(genes = c('CD14', 'CD68', 'CSF1R', 'FCGR3A'))
  ),
  tissue_name = 'human PBMC',
  model = 'gpt-5.5',
  api_key = NA  # Returns prompt only without making API call
)

# Example 2: Using with Seurat pipeline and OpenAI model
## Not run: 
library(Seurat)

# Load example data
data("pbmc_small")

# Find marker genes
all.markers <- FindAllMarkers(
  object = pbmc_small,
  only.pos = TRUE,
  min.pct = 0.25,
  logfc.threshold = 0.25
)

# Set API key in environment variable (recommended approach)
Sys.setenv(OPENAI_API_KEY = "your-openai-api-key")

# Get cell type annotations using OpenAI model
openai_annotations <- annotate_cell_types(
  input = all.markers,
  tissue_name = 'human PBMC',
  model = 'gpt-5.5',
  api_key = Sys.getenv("OPENAI_API_KEY"),
  top_gene_count = 15
)

# Example 3: Using Anthropic Claude model
Sys.setenv(ANTHROPIC_API_KEY = "your-anthropic-api-key")

claude_annotations <- annotate_cell_types(
  input = all.markers,
  tissue_name = 'human PBMC',
  model = 'claude-opus-4-7',
  api_key = Sys.getenv("ANTHROPIC_API_KEY"),
  top_gene_count = 15
)

# Example 4: Using OpenRouter to access multiple models
Sys.setenv(OPENROUTER_API_KEY = "your-openrouter-api-key")

# Access OpenAI models through OpenRouter
openrouter_gpt4_annotations <- annotate_cell_types(
  input = all.markers,
  tissue_name = 'human PBMC',
  model = 'openai/gpt-5.5',  # Note the provider/model format
  api_key = Sys.getenv("OPENROUTER_API_KEY"),
  top_gene_count = 15
)

# Access Anthropic models through OpenRouter
openrouter_claude_annotations <- annotate_cell_types(
  input = all.markers,
  tissue_name = 'human PBMC',
  model = 'anthropic/claude-opus-4.6',  # Note the provider/model format
  api_key = Sys.getenv("OPENROUTER_API_KEY"),
  top_gene_count = 15
)

# Example 5: Using with mouse brain data
mouse_annotations <- annotate_cell_types(
  input = mouse_markers,  # Your mouse marker genes
  tissue_name = 'mouse brain',  # Specify correct tissue for context
  model = 'gpt-5.5',
  api_key = Sys.getenv("OPENAI_API_KEY"),
  top_gene_count = 20,  # Use more genes for complex tissues
  debug = TRUE  # Enable debug output
)

## End(Not run)

Description

Anthropic API Processor

Anthropic API Processor

Details

Concrete implementation of BaseAPIProcessor for Anthropic models. Handles Anthropic-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> AnthropicProcessor

Methods

Public methods

• AnthropicProcessor$new()

• AnthropicProcessor$get_default_api_url()

• AnthropicProcessor$make_api_call()

• AnthropicProcessor$extract_response_content()

• AnthropicProcessor$extract_usage()

• AnthropicProcessor$clone()

Method new()

Initialize Anthropic processor

Usage

AnthropicProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Anthropic API URL

Usage

AnthropicProcessor$get_default_api_url()

Method make_api_call()

Make API call to Anthropic

Usage

AnthropicProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Anthropic API response

Usage

AnthropicProcessor$extract_response_content(response, model)

Arguments

Method extract_usage()

Extract normalized Anthropic token usage

Usage

AnthropicProcessor$extract_usage(response)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

AnthropicProcessor$clone(deep = FALSE)

Arguments

Description

Base API Processor Class

Base API Processor Class

Details

Abstract base class for API processors that provides common functionality including unified logging, error handling, input processing, and response validation. This eliminates code duplication across all provider-specific processors.

Public fields

Methods

Public methods

• BaseAPIProcessor$new()

• BaseAPIProcessor$process_request()

• BaseAPIProcessor$get_api_url()

• BaseAPIProcessor$get_default_api_url()

• BaseAPIProcessor$make_api_call()

• BaseAPIProcessor$extract_response_content()

• BaseAPIProcessor$extract_usage()

• BaseAPIProcessor$clone()

Method new()

Initialize the base API processor

Usage

BaseAPIProcessor$new(provider_name, base_url = NULL)

Arguments

Method process_request()

Main entry point for processing API requests

Usage

BaseAPIProcessor$process_request(prompt, model, api_key, normalize = TRUE)

Arguments

Method get_api_url()

Get the API URL to use for requests

Usage

BaseAPIProcessor$get_api_url()

Method get_default_api_url()

Abstract method to be implemented by subclasses for getting default API URL

Usage

BaseAPIProcessor$get_default_api_url()

Method make_api_call()

Abstract method to be implemented by subclasses for making the actual API call

Usage

BaseAPIProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Abstract method to be implemented by subclasses for extracting content from response

Usage

BaseAPIProcessor$extract_response_content(response, model)

Arguments

Method extract_usage()

Extract normalized token usage from a provider response

Usage

BaseAPIProcessor$extract_usage(response)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

BaseAPIProcessor$clone(deep = FALSE)

Arguments

Description

Manages caching of consensus analysis results

Public fields

Methods

Public methods

• CacheManager$new()

• CacheManager$get_cache_dir()

• CacheManager$generate_key()

• CacheManager$save_to_cache()

• CacheManager$load_from_cache()

• CacheManager$has_cache()

• CacheManager$get_cache_stats()

• CacheManager$clear_cache()

• CacheManager$validate_cache()

• CacheManager$clone()

Method new()

Initialize cache manager

• NULL (default): Uses system cache directory via tools::R_user_dir()

• "local": Uses .mllmcelltype_cache in current directory

• "temp": Uses temporary directory (cleared on R restart)

• Custom path: Any other string is used as directory path

Usage

CacheManager$new(cache_dir = NULL)

Arguments

Method get_cache_dir()

Get actual cache directory path

Usage

CacheManager$get_cache_dir()

Method generate_key()

Generate cache key from input parameters (improved version)

Usage

CacheManager$generate_key(
  input,
  models,
  cluster_id,
  tissue_name = "",
  top_gene_count = 10,
  discussion_context = NULL
)

Arguments

Method save_to_cache()

Save results to cache

Usage

CacheManager$save_to_cache(key, data)

Arguments

Method load_from_cache()

Load results from cache

Usage

CacheManager$load_from_cache(key)

Arguments

Method has_cache()

Check if results exist in cache

Usage

CacheManager$has_cache(key)

Arguments

Method get_cache_stats()

Get cache statistics

Usage

CacheManager$get_cache_stats()

Method clear_cache()

Clear all cache

Usage

CacheManager$clear_cache(confirm = FALSE)

Arguments

Method validate_cache()

Validate cache content

Usage

CacheManager$validate_cache(key)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

CacheManager$clone(deep = FALSE)

Arguments

Description

This function runs the same input through multiple models and compares their predictions. It provides both individual predictions and a consensus analysis.

Usage

compare_model_predictions(
  input,
  tissue_name,
  models = c("claude-opus-4-7", "gpt-5.5", "gemini-3.1-pro-preview", "deepseek-v4-flash",
    "qwen3.6-plus", "grok-4.3"),
  api_keys,
  top_gene_count = 10,
  consensus_threshold = 0.5,
  base_urls = NULL
)

Arguments

Value

List containing individual model predictions and consensus analysis If a cluster has fewer than two valid predictions after alignment/padding, its consensus-related outputs are NA.

Note

This function uses create_standardization_prompt from prompt_templates.R Supported models:

• OpenAI: 'gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini'

• Anthropic: 'claude-opus-4-7', 'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001'

• DeepSeek: 'deepseek-v4-flash', 'deepseek-v4-pro'

• Google: 'gemini-3.1-pro-preview', 'gemini-3-flash-preview', 'gemini-3.1-flash-lite'

• Alibaba: 'qwen3.6-max-preview', 'qwen3.6-plus', 'qwen3.6-flash'

• Stepfun: 'step-3.5-flash', 'step-3.5-flash-2603', 'step-3'

• Zhipu/Z.AI: 'glm-5.1', 'glm-5-turbo', 'glm-5'

• MiniMax: 'MiniMax-M2.7', 'MiniMax-M2.7-highspeed', 'MiniMax-M2.5'

• X.AI: 'grok-4.3', 'grok-4.3-latest', 'grok-latest'

• OpenRouter: Provides access to models from multiple providers through a single API. Format: 'provider/model-name'

  • OpenAI models: 'openai/gpt-5.5', 'openai/gpt-5.4-mini'

  • Anthropic models: 'anthropic/claude-opus-4.7', 'anthropic/claude-sonnet-4.6'

  • Google models: 'google/gemini-3.1-pro-preview', 'google/gemini-3-flash-preview'

  • X.AI models: 'x-ai/grok-4.3'

  • Stepfun models: 'stepfun/step-3.5-flash'

1. With provider names as keys: list("openai" = "sk-...", "anthropic" = "sk-ant-...", "openrouter" = "sk-or-...")

2. With model names as keys: list("gpt-5.5" = "sk-...", "claude-sonnet-4-6" = "sk-ant-...")

The system first tries to find the API key using the provider name. If not found, it then tries using the model name. Example:

api_keys <- list(
  "openai" = Sys.getenv("OPENAI_API_KEY"),
  "anthropic" = Sys.getenv("ANTHROPIC_API_KEY"),
  "openrouter" = Sys.getenv("OPENROUTER_API_KEY"),
  "claude-opus-4-7" = "your-claude-opus-key"
)

Examples

## Not run: 
# Compare predictions using different models
api_keys <- list(
  "claude-sonnet-4-6" = "your-anthropic-key",
  "deepseek-v4-pro" = "your-deepseek-key",
  "gemini-3.1-pro-preview" = "your-gemini-key",
  "qwen3.6-plus" = "your-qwen-key"
)

results <- compare_model_predictions(
  input = list(gs1=c('CD4','CD3D'), gs2='CD14'),
  tissue_name = 'PBMC',
  api_keys = api_keys
)

## End(Not run)

Description

Set global logger configuration

Usage

configure_logger(level = "INFO", console_output = FALSE, json_format = TRUE)

Arguments

Value

Invisible logger object

Description

Create prompt for cell type annotation

Usage

create_annotation_prompt(input, tissue_name, top_gene_count = 10)

Arguments

Value

A list with prompt (formatted prompt text), expected_count (number of clusters), and gene_lists (cluster ID to marker genes mapping).

Description

Create reasoning-aware prompt for cell type annotation

Usage

create_reasoning_annotation_prompt(input, tissue_name, top_gene_count = 10)

Arguments

Value

A list with prompt (formatted prompt text), expected_count (number of clusters), and gene_lists (cluster ID to marker genes mapping).

Description

DeepSeek API Processor

DeepSeek API Processor

Details

Concrete implementation of BaseAPIProcessor for DeepSeek models. Handles DeepSeek-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> DeepSeekProcessor

Methods

Public methods

• DeepSeekProcessor$new()

• DeepSeekProcessor$get_default_api_url()

• DeepSeekProcessor$make_api_call()

• DeepSeekProcessor$extract_response_content()

• DeepSeekProcessor$clone()

Method new()

Initialize DeepSeek processor

Usage

DeepSeekProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default DeepSeek API URL

Usage

DeepSeekProcessor$get_default_api_url()

Method make_api_call()

Make API call to DeepSeek

Usage

DeepSeekProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from DeepSeek API response

Usage

DeepSeekProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

DeepSeekProcessor$clone(deep = FALSE)

Arguments

Description

Gemini API Processor

Gemini API Processor

Details

Concrete implementation of BaseAPIProcessor for Gemini models. Handles Gemini-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> GeminiProcessor

Methods

Public methods

• GeminiProcessor$new()

• GeminiProcessor$get_default_api_url()

• GeminiProcessor$get_api_url_for_model()

• GeminiProcessor$make_api_call()

• GeminiProcessor$extract_response_content()

• GeminiProcessor$extract_usage()

• GeminiProcessor$clone()

Method new()

Initialize Gemini processor

Usage

GeminiProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Gemini API URL template

Usage

GeminiProcessor$get_default_api_url()

Method get_api_url_for_model()

Get API URL for specific model

Usage

GeminiProcessor$get_api_url_for_model(model)

Arguments

Method make_api_call()

Make API call to Gemini

Usage

GeminiProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Gemini API response

Usage

GeminiProcessor$extract_response_content(response, model)

Arguments

Method extract_usage()

Extract normalized Gemini token usage

Usage

GeminiProcessor$extract_usage(response)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

GeminiProcessor$clone(deep = FALSE)

Arguments

Description

Retrieves a configured API key by checking the model's provider name first, followed by the exact model name.

Usage

get_api_key(model, api_keys)

Arguments

Value

A trimmed API key string, or NULL when no valid key is configured.

Description

Get the global logger instance

Usage

get_logger()

Description

This function determines the appropriate provider (e.g., OpenAI, Anthropic, Google, OpenRouter) based on the model name. Uses prefix-based matching for efficient and maintainable provider detection. New models following existing naming conventions are automatically supported.

Usage

get_provider(model)

Arguments

Details

Supported providers and model prefixes:

• OpenAI: gpt-, o1, o3*, o4*, chatgpt-, codex- (e.g., 'gpt-5.5', 'gpt-5.4-mini')

• Anthropic: claude-* (e.g., 'claude-opus-4-7', 'claude-sonnet-4-6')

• DeepSeek: deepseek-* (e.g., 'deepseek-v4-flash', 'deepseek-v4-pro')

• Google: gemini-* (e.g., 'gemini-3.1-pro-preview', 'gemini-3-flash-preview')

• Qwen: qwen*, qwq-* (e.g., 'qwen3.6-plus', 'qwen3.6-flash')

• Stepfun: step-* (e.g., 'step-3.5-flash', 'step-3')

• Zhipu: glm-, chatglm (e.g., 'glm-5.1', 'glm-5-turbo')

• MiniMax: minimax-* (e.g., 'MiniMax-M2.7', 'MiniMax-M2.5')

• Grok: grok-* (e.g., 'grok-4.3', 'grok-4.3-latest')

• Kimi (Moonshot AI Open Platform): kimi-, moonshot- (e.g., 'kimi-k2.6', 'moonshot-v1-8k')

• OpenRouter: Any model with '/' in the name (e.g., 'openai/gpt-5.5', 'anthropic/claude-opus-4.7')

Value

Character string of the provider name (e.g., "openai", "anthropic").

Description

Grok API Processor

Grok API Processor

Details

Concrete implementation of BaseAPIProcessor for Grok models. Handles Grok-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> GrokProcessor

Methods

Public methods

• GrokProcessor$new()

• GrokProcessor$get_default_api_url()

• GrokProcessor$make_api_call()

• GrokProcessor$extract_response_content()

• GrokProcessor$clone()

Method new()

Initialize Grok processor

Usage

GrokProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Grok API URL

Usage

GrokProcessor$get_default_api_url()

Method make_api_call()

Make API call to Grok

Usage

GrokProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Grok API response

Usage

GrokProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

GrokProcessor$clone(deep = FALSE)

Arguments

Description

This function implements an interactive voting and discussion mechanism where multiple LLMs collaborate to reach a consensus on cell type annotations, particularly focusing on clusters with low agreement. The process includes:

1. Initial voting by all LLMs

2. Identification of controversial clusters

3. Detailed discussion for controversial clusters

4. Final summary by a designated LLM (default: Claude)

Usage

interactive_consensus_annotation(
  input,
  tissue_name,
  models = c("claude-opus-4-7", "gpt-5.5", "gemini-3.1-pro-preview", "deepseek-v4-flash",
    "grok-4.3"),
  api_keys,
  top_gene_count = 10,
  controversy_threshold = 0.7,
  entropy_threshold = 1,
  max_discussion_rounds = 3,
  consensus_check_model = NULL,
  log_dir = "logs",
  cache_dir = NULL,
  use_cache = TRUE,
  base_urls = NULL,
  clusters_to_analyze = NULL,
  force_rerun = FALSE
)

Arguments

Value

A list containing:

• initial_results: Initial voting results, consensus checks, and controversial cluster IDs

• final_annotations: Final annotations keyed by cluster ID

• controversial_clusters: Clusters identified as controversial

• discussion_logs: Detailed discussion logs for controversial clusters

• session_id: Logger session identifier

• voting_results: Backward-compatible alias of initial_results

• discussion_results: Backward-compatible alias of discussion_logs

• final_consensus: Backward-compatible alias of final_annotations

Description

Kimi API Processor

Kimi API Processor

Details

Concrete implementation of BaseAPIProcessor for Kimi models. By default it targets the Moonshot AI Open Platform over the OpenAI-compatible Chat Completions protocol, with k2 thinking mode disabled for deterministic output. A custom base_url may instead point at the Kimi Code platform (api.kimi.com/coding), which speaks both protocols; the protocol is inferred from the effective endpoint URL. URLs ending in '/messages' use the Anthropic Messages protocol; the Kimi Code base 'https://api.kimi.com/coding' and URLs ending in '/chat/completions' use OpenAI-compatible Chat Completions.

Super class

mLLMCelltype::BaseAPIProcessor -> KimiProcessor

Methods

Public methods

• KimiProcessor$new()

• KimiProcessor$get_default_api_url()

• KimiProcessor$make_api_call()

• KimiProcessor$extract_response_content()

• KimiProcessor$extract_usage()

• KimiProcessor$clone()

Method new()

Initialize Kimi processor

Usage

KimiProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Kimi API URL

Usage

KimiProcessor$get_default_api_url()

Method make_api_call()

Make API call to Kimi

Usage

KimiProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Kimi API response

Usage

KimiProcessor$extract_response_content(response, model)

Arguments

Method extract_usage()

Extract normalized token usage from a Kimi API response

Usage

KimiProcessor$extract_usage(response)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

KimiProcessor$clone(deep = FALSE)

Arguments

Description

Get list of registered custom models

Usage

list_custom_models()

Description

Get list of registered custom providers

Usage

list_custom_providers()

Description

Convenience functions for logging

Usage

log_debug(message, context = NULL)

log_info(message, context = NULL)

log_warn(message, context = NULL)

log_error(message, context = NULL)

Arguments

Value

Invisible NULL

Description

Minimax API Processor

Minimax API Processor

Details

Concrete implementation of BaseAPIProcessor for Minimax models. Handles Minimax-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> MinimaxProcessor

Methods

Public methods

• MinimaxProcessor$new()

• MinimaxProcessor$get_default_api_url()

• MinimaxProcessor$make_api_call()

• MinimaxProcessor$extract_response_content()

• MinimaxProcessor$clone()

Method new()

Initialize Minimax processor

Usage

MinimaxProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default MiniMax OpenAI-compatible chat completions API URL

Usage

MinimaxProcessor$get_default_api_url()

Method make_api_call()

Make API call to Minimax

Usage

MinimaxProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Minimax API response

Usage

MinimaxProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

MinimaxProcessor$clone(deep = FALSE)

Arguments

Description

Display the cache directory location

Usage

mllmcelltype_cache_dir(cache_dir = NULL)

Arguments

Value

Invisible cache directory path

Examples

## Not run: 
mllmcelltype_cache_dir()
mllmcelltype_cache_dir("local")

## End(Not run)

Description

Clear the mLLMCelltype cache

Usage

mllmcelltype_clear_cache(cache_dir = NULL)

Arguments

Value

Invisible NULL

Examples

## Not run: 
mllmcelltype_clear_cache()
mllmcelltype_clear_cache("local")

## End(Not run)

Description

OpenAI API Processor

OpenAI API Processor

Details

Concrete implementation of BaseAPIProcessor for OpenAI models. Handles OpenAI-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> OpenAIProcessor

Methods

Public methods

• OpenAIProcessor$new()

• OpenAIProcessor$get_default_api_url()

• OpenAIProcessor$make_api_call()

• OpenAIProcessor$extract_response_content()

• OpenAIProcessor$clone()

Method new()

Initialize OpenAI processor

Usage

OpenAIProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default OpenAI API URL

Usage

OpenAIProcessor$get_default_api_url()

Method make_api_call()

Make API call to OpenAI

Usage

OpenAIProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from OpenAI API response

Usage

OpenAIProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

OpenAIProcessor$clone(deep = FALSE)

Arguments

Description

OpenRouter API Processor

OpenRouter API Processor

Details

Concrete implementation of BaseAPIProcessor for OpenRouter models. Handles OpenRouter-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> OpenRouterProcessor

Methods

Public methods

• OpenRouterProcessor$new()

• OpenRouterProcessor$get_default_api_url()

• OpenRouterProcessor$make_api_call()

• OpenRouterProcessor$extract_response_content()

• OpenRouterProcessor$clone()

Method new()

Initialize OpenRouter processor

Usage

OpenRouterProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default OpenRouter API URL

Usage

OpenRouterProcessor$get_default_api_url()

Method make_api_call()

Make API call to OpenRouter

Usage

OpenRouterProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from OpenRouter API response

Usage

OpenRouterProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

OpenRouterProcessor$clone(deep = FALSE)

Arguments

Description

Qwen API Processor

Qwen API Processor

Details

Concrete implementation of BaseAPIProcessor for Qwen models. Handles Qwen-specific API calls, authentication, and response parsing.

Qwen has OpenAI-compatible chat completions endpoints:

• International (US): https://dashscope-us.aliyuncs.com/compatible-mode/v1/chat/completions

• Domestic (China): https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions

• Legacy international: https://dashscope-intl.aliyuncs.com/compatible-mode/v1/chat/completions The processor automatically tries international first, then domestic, then legacy international.

Super class

mLLMCelltype::BaseAPIProcessor -> QwenProcessor

Methods

Public methods

• QwenProcessor$new()

• QwenProcessor$get_default_api_url()

• QwenProcessor$get_working_api_url()

• QwenProcessor$make_api_call()

• QwenProcessor$extract_response_content()

• QwenProcessor$clone()

Method new()

Test if an endpoint is accessible

Initialize Qwen processor

Usage

QwenProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Qwen OpenAI-compatible chat completions API URL

Usage

QwenProcessor$get_default_api_url()

Method get_working_api_url()

Get working Qwen API URL with automatic endpoint detection

Usage

QwenProcessor$get_working_api_url(api_key)

Arguments

Method make_api_call()

Make API call to Qwen

Usage

QwenProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Qwen API response

Usage

QwenProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

QwenProcessor$clone(deep = FALSE)

Arguments

Description

Register a custom model for a provider

Usage

register_custom_model(model_name, provider_name, model_config = list())

Arguments

Value

Invisible TRUE on success

Examples

## Not run: 
register_custom_model(
  model_name = "my_model",
  provider_name = "my_provider",
  model_config = list(
    temperature = 0.7,
    max_tokens = 2000
  )
)

## End(Not run)

Description

Register a custom LLM provider

Usage

register_custom_provider(provider_name, process_fn, description = NULL)

Arguments

Value

Invisible NULL

Examples

## Not run: 
register_custom_provider(
  provider_name = "my_provider",
  process_fn = function(prompt, model, api_key) {
    # Custom implementation
    response <- httr::POST(
      url = "your_api_endpoint",
      body = list(prompt = prompt),
      encode = "json"
    )
    return(httr::content(response)$choices[[1]]$text)
  }
)

## End(Not run)

Description

StepFun API Processor

StepFun API Processor

Details

Concrete implementation of BaseAPIProcessor for StepFun models. Handles StepFun-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> StepFunProcessor

Methods

Public methods

• StepFunProcessor$new()

• StepFunProcessor$get_default_api_url()

• StepFunProcessor$make_api_call()

• StepFunProcessor$extract_response_content()

• StepFunProcessor$clone()

Method new()

Initialize StepFun processor

Usage

StepFunProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default StepFun API URL

Usage

StepFunProcessor$get_default_api_url()

Method make_api_call()

Make API call to StepFun

Usage

StepFunProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from StepFun API response

Usage

StepFunProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

StepFunProcessor$clone(deep = FALSE)

Arguments

Description

Unified Logger for mLLMCelltype Package

Unified Logger for mLLMCelltype Package

Details

This logger provides centralized, multi-level logging with structured output, log rotation, and performance monitoring capabilities.

Public fields

Methods

Public methods

• UnifiedLogger$new()

• UnifiedLogger$debug()

• UnifiedLogger$info()

• UnifiedLogger$warn()

• UnifiedLogger$error()

• UnifiedLogger$log_api_call()

• UnifiedLogger$log_api_request_response()

• UnifiedLogger$log_cache_operation()

• UnifiedLogger$log_cluster_progress()

• UnifiedLogger$log_discussion()

• UnifiedLogger$log_model_response()

• UnifiedLogger$get_performance_summary()

• UnifiedLogger$cleanup_logs()

• UnifiedLogger$set_level()

• UnifiedLogger$clone()

Method new()

Initialize the unified logger

Usage

UnifiedLogger$new(
  base_dir = "logs",
  level = "INFO",
  max_size = 10,
  max_files = 5,
  console_output = FALSE,
  json_format = TRUE
)

Arguments

Method debug()

Log a debug message

Usage

UnifiedLogger$debug(message, context = NULL)

Arguments

Method info()

Log an info message

Usage

UnifiedLogger$info(message, context = NULL)

Arguments

Method warn()

Log a warning message

Usage

UnifiedLogger$warn(message, context = NULL)

Arguments

Method error()

Log an error message

Usage

UnifiedLogger$error(message, context = NULL)

Arguments

Method log_api_call()

Log API call performance

Usage

UnifiedLogger$log_api_call(
  provider,
  model,
  duration,
  success = TRUE,
  tokens = NULL
)

Arguments

Method log_api_request_response()

Log complete API request and response for debugging and audit

Usage

UnifiedLogger$log_api_request_response(
  provider,
  model,
  prompt_content,
  response_content,
  request_metadata = NULL,
  response_metadata = NULL
)

Arguments

Method log_cache_operation()

Log cache operations

Usage

UnifiedLogger$log_cache_operation(operation, key, size = NULL)

Arguments

Method log_cluster_progress()

Log cluster annotation progress

Usage

UnifiedLogger$log_cluster_progress(cluster_id, stage, progress = NULL)

Arguments

Method log_discussion()

Log detailed cluster discussion with complete model conversations

Usage

UnifiedLogger$log_discussion(cluster_id, event_type, data = NULL)

Arguments

Method log_model_response()

Log model response with concise summary in main log and full text in file

Usage

UnifiedLogger$log_model_response(
  provider,
  model,
  response,
  stage = "annotation",
  cluster_id = NULL
)

Arguments

Method get_performance_summary()

Get performance summary

Usage

UnifiedLogger$get_performance_summary()

Method cleanup_logs()

Clean up old log files

Usage

UnifiedLogger$cleanup_logs(force = FALSE)

Arguments

Method set_level()

Set logging level

Usage

UnifiedLogger$set_level(level)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

UnifiedLogger$clone(deep = FALSE)

Arguments

Description

Zhipu API Processor

Zhipu API Processor

Details

Concrete implementation of BaseAPIProcessor for Zhipu models. Handles Zhipu-specific API calls, authentication, and response parsing.

Super class

mLLMCelltype::BaseAPIProcessor -> ZhipuProcessor

Methods

Public methods

• ZhipuProcessor$new()

• ZhipuProcessor$get_default_api_url()

• ZhipuProcessor$make_api_call()

• ZhipuProcessor$extract_response_content()

• ZhipuProcessor$clone()

Method new()

Initialize Zhipu processor

Usage

ZhipuProcessor$new(base_url = NULL)

Arguments

Method get_default_api_url()

Get default Zhipu API URL

Usage

ZhipuProcessor$get_default_api_url()

Method make_api_call()

Make API call to Zhipu

Usage

ZhipuProcessor$make_api_call(chunk_content, model, api_key)

Arguments

Method extract_response_content()

Extract response content from Zhipu API response

Usage

ZhipuProcessor$extract_response_content(response, model)

Arguments

Method clone()

The objects of this class are cloneable with this method.

Usage

ZhipuProcessor$clone(deep = FALSE)

Arguments