chatAI4R: Chat-Based Interactive Artificial Intelligence for R

Version 1.1.0 - Linux Installation Improvements & CI/CD Integration

GitHub/chatAI4R

Description

chatAI4R, Chat-based Interactive Artificial Intelligence for R, is an R package designed to integrate the OpenAI API and other APIs for artificial intelligence (AI) applications. This package leverages large language model (LLM)-based AI techniques, enabling efficient knowledge discovery and data analysis. chatAI4R provides basic R functions for using LLM and a set of R functions to support the creation of prompts for using LLM. The LLMs allow us to extend the world of R. Additionally, I strongly believe that the LLM is becoming so generalized that "Are you searching Google?" is likely to evolve into "Are you LLMing?".

chatAI4R is an experimental project aimed at developing and implementing various LLM applications in R. Furthermore, the package is under continuous development with a focus on extending its capabilities for bioinformatics analysis.

🎯 Who is this for?

Key Difference: Beyond multi-functional API wrappers - provides a 4-layer architecture from basic API access to expert-level workflows and domain-specific analysis tools.

✨ Key Features

🚀 Multi-API Support (6 AI Services)

🏗️ 4-Layer Architecture (Beyond Simple API Wrapper)

Layer 1 - Core Functions: Direct API access (chat4R, gemini4R, multiLLMviaionet) Layer 2 - Advanced Functions: Intelligent processing and domain-specific analysis (interpretResult, conversation4R, geminiGrounding4R) Layer 3 - Workflow Functions: Multi-agent collaboration and package automation (discussion_flow_v2, autocreateFunction4R) Layer 4 - Integration Functions: Ecosystem connectivity (deploying R-based web APIs via plumber for backend embedding, and GUI support)

🔒 Production-Ready Security

Note: Translation features separated to deepRstudio package. Image generation features in stableDiffusion4R package.

Installation of the chatAI4R package

1. Start R / RStudio console.

2. Run the following commands in the R console:

CRAN-version installation

# CRAN-version installation
install.packages("chatAI4R")
library(chatAI4R)

Dev-version installation (Recommended)

# Dev-version installation
# devtools::install_github("kumeS/chatAI4R")
install.packages("chatAI4R", repos = c('https://kumes.r-universe.dev', 'https://cloud.r-project.org'))
library(chatAI4R)

Installation from source

#For MacOS X, installation from source
system("wget https://github.com/kumeS/chatAI4R/archive/refs/tags/v0.2.3.tar.gz")
#or system("wget https://github.com/kumeS/chatAI4R/archive/refs/tags/v0.2.3.tar.gz --no-check-certificate")
system("R CMD INSTALL v0.2.3.tar.gz")

4. Set the API keys for Multi-API Support

chatAI4R supports multiple AI APIs. Configure the APIs you want to use:

Required: OpenAI API (for most functions)

Register at OpenAI website and obtain your API key.

# Set your OpenAI API key (required)
Sys.setenv(OPENAI_API_KEY = "sk-your-openai-api-key")

Optional: Additional AI APIs (for extended functions)

# Google Gemini API (for gemini4R, geminiGrounding4R)
Sys.setenv(GoogleGemini_API_KEY = "your-gemini-api-key")

# Replicate API (for replicatellmAPI4R)
Sys.setenv(Replicate_API_KEY = "your-replicate-api-key")

# Dify API (for DifyChat4R)
Sys.setenv(DIFY_API_KEY = "your-dify-api-key")

# DeepL API (for discussion_flow functions with translation)
Sys.setenv(DeepL_API_KEY = "your-deepl-api-key")

# io.net API (for multiLLMviaionet functions)
Sys.setenv(IONET_API_KEY = "your-ionet-api-key")

Permanent Configuration

Create an .Rprofile file in your home directory and add your API keys:

# Create a file
file.create("~/.Rprofile") 

# Add all your API keys to the file
cat('
# chatAI4R API Keys Configuration
Sys.setenv(OPENAI_API_KEY = "sk-your-openai-api-key")
Sys.setenv(GoogleGemini_API_KEY = "your-gemini-api-key")
Sys.setenv(Replicate_API_KEY = "your-replicate-api-key")
Sys.setenv(DIFY_API_KEY = "your-dify-api-key")
Sys.setenv(DeepL_API_KEY = "your-deepl-api-key")
Sys.setenv(IONET_API_KEY = "your-ionet-api-key")
', file = "~/.Rprofile", append = TRUE)

# [MacOS X] Open the file and edit it
system("open ~/.Rprofile")

Note: Please be aware of newline character inconsistencies across different operating systems.

🔧 Troubleshooting for instllation of this package

Fix Corrupted Help Database Error

If you encounter: Error in fetch(key): lazy-load database '...chatAI4R.rdb' is corrupt

Cause: Package help database (.rdb file) corruption due to incomplete installation, system crash during loading, or R version upgrade.

Quick Fix:

# Automated repair (removes corrupted install, reinstalls from GitHub, verifies)
system.file("rebuild_package.R", package = "chatAI4R") |> source()

# Then restart R
.rs.restartR()  # RStudio: or Session > Restart R (Ctrl+Shift+F10)

Manual alternative:

remove.packages("chatAI4R")
remotes::install_github("kumeS/chatAI4R", force = TRUE)
.rs.restartR()

🚀 Quick Start

Basic Usage

library(chatAI4R)

# 1. One-shot chat
chat4R("Explain linear regression assumptions")

# 2. Conversation with memory
conversation4R("What's the best clustering algorithm for this data?")
conversation4R("It has 10,000 samples and 50 features")

# 3. R package development
autocreateFunction4R(
  Func_description = "Create a function to calculate log2 fold change with error handling"
)
# → Generates function + Roxygen2 documentation

Note regarding output formatting: Current AI models tend to emit many literal \n sequences in generated text. This package intentionally preserves \n so it formats as intended when displayed via cat() (rather than print()), which improves readability in typical console usage. It is recommended to use cat() to display the output.

Advanced Features

Statistical Interpretation (13+ domains):

model <- lm(mpg ~ wt + hp, data = mtcars)
interpretResult(analysis_type = "regression", result_text = summary(model))

Multi-Agent Discussion

Collaborative problem-solving with multiple specialized agents:

# Basic discussion
discussion_flow_v1(
  issue = "Optimize machine learning pipeline",
  Domain = "data science"
)

# Advanced discussion with custom settings
discussion_flow_v2(
  issue = "Optimize machine learning pipeline",
  Domain = "data science",
  Sentence_difficulty = 2,
  R_expert_setting = TRUE,
  rep_x = 3
)

R Package Development Utils

Streamline package creation and documentation:

# Add Roxygen2 documentation to selected code
# (Select the function definition in RStudio first)
addRoxygenDescription(Model = "gpt-5-nano", SelectedCode = TRUE)

# Create function from clipboard content
createRfunction(Model = "gpt-5", SelectedCode = FALSE)

💡 Use Cases

R Package Development: Design packages, generate functions with Roxygen2 docs, debug errors Data Analysis: Interpret statistical results, process literature, extract insights Multi-Model Comparison: Compare 23+ LLM responses for robust analysis

Tutorial

Basic usage

Testing

chatAI4R includes a comprehensive automated testing framework:

Prompts for chatGPT / GPT-4

File Description Prompt
create_flowcharts A prompt to create a flowchart Prompt
create_roxygen2_v01 A prompt to create a roxygen2 description Prompt
create_roxygen2_v02 A prompt to create a roxygen2 description Prompt
edit_DESCRIPTION A prompt to edit DESCRIPTION Prompt
Img2txt_prompt_v01 A prompt to create a i2i prompt Prompt
Img2txt_prompt_v02 A prompt to create a i2i prompt Prompt

📚 Function Reference

chatAI4R provides 54 functions organized in a 4-layer architecture. Below are the most commonly used functions. For a complete function list, see Full Function Reference.

🎯 Most Used Functions

Getting Started:

Data Analysis:

R Development:

Advanced Workflows:

🔍 Full Function Reference

The chatAI4R package is structured as 4 Layered Functions that provide increasingly sophisticated AI capabilities, from basic API access to expert-level data mining and analysis.

🟢 Layer 1: Core Functions (API Access) - Click to expand

Core functions provide direct access to multiple AI APIs, enabling basic AI operations.

Function Description API Service Script Flowchart
chat4R Chat with GPT models using OpenAI API (One-shot) OpenAI Script Flowchart
chat4R_history Use chat history for OpenAI's GPT model OpenAI Script Flowchart
chat4R_streaming Chat with GPT models using streaming response OpenAI Script
chat4Rv2 Enhanced chat interface with system prompt support OpenAI Script
textEmbedding Text Embedding from OpenAI Embeddings API (1536-dimensional) OpenAI Script Flowchart
vision4R Advanced image analysis and interpretation OpenAI Script
gemini4R Chat with Google Gemini AI models Google Gemini Script
replicatellmAPI4R Access various LLM models through Replicate platform Replicate Script
DifyChat4R Chat and completion endpoints through Dify platform Dify Script
multiLLMviaionet Execute multiple LLM models simultaneously via io.net API io.net Script
list_ionet_models List available LLM models on io.net platform io.net Script
completions4R ⚠️ DEPRECATED - Generate text using OpenAI completions API (scheduled for removal) OpenAI Script Flowchart

Utility Functions (Non-API)

Function Description Script
slow_print_v2 Slowly print text with typewriter effect Script
ngsub Remove extra spaces and newline characters Script
removeQuotations Remove all types of quotations from text Script
speakInEN Text-to-speech functionality for English Script
speakInJA Text-to-speech functionality for Japanese Script
speakInJA_v2 Enhanced text-to-speech functionality for Japanese Script
🟡 Layer 2: Usage/Task Functions - Click to expand

🟡 2nd Layered Functions (Usage/Task)

Execution of simple LLM tasks: Chat memory, translation, proofreading, etc.

These functions combine core APIs to perform specific tasks and maintain conversation context.

Function Description Script Flowchart
conversation4R Manage conversation with persistent history Script Flowchart
TextSummary Summarize long texts with intelligent chunking Script
TextSummaryAsBullet Summarize selected text into bullet points Script
revisedText Revision for scientific text with AI assistance Script
proofreadEnglishText Proofread English text via RStudio API Script
proofreadText Proofread text with grammar and style correction Script
enrichTextContent Enrich text content with additional information Script
convertBullet2Sentence Convert bullet points to sentences Script
🟠 Layer 3: Workflow Functions - Click to expand

🟠 3rd Layered Functions (Workflow)

LLM Workflow, LLM Bots, R Packaging Supports

Advanced workflow functions that orchestrate multiple AI operations and support complex development tasks.

Function Description Script
discussion_flow_v1 Multi-agent expert system simulation (3 roles) Script
discussion_flow_v2 Enhanced multi-bot conversation system Script
createSpecifications4R Create detailed specifications for R functions Script
createRfunction Create R functions from selected text or clipboard Script
createRcode Generate R code from clipboard content Script
convertRscript2Function Convert R script to structured R function Script
addRoxygenDescription Add Roxygen documentation to R functions Script
OptimizeRcode Optimize and complete R code Script
RcodeImprovements Suggest improvements for R code from clipboard Script
designPackage Design complete R packages Script
addCommentCode Add intelligent comments to R code (supports OpenAI & Gemini) Script
checkErrorDet Analyze and explain R error messages Script
checkErrorDet_JP Analyze and explain R error messages (Japanese) Script
autocreateFunction4R ✨ UPDATED - Generate and improve R functions (now uses chat4R) Script
supportIdeaGeneration Support idea generation from text input Script
createEBAYdes Create professional eBay product descriptions Script
createImagePrompt_v1 Create image generation prompts Script
createImagePrompt_v2 Enhanced image generation prompts Script
🔴 Layer 4: Expertise Functions - Click to expand

🔴 4th Layered Functions (Expertise)

Data mining & Advanced Analysis

Expert-level functions that provide sophisticated data analysis, pattern recognition, and knowledge extraction capabilities.

Function Description Script
interpretResult Interpret analysis results across 13 analytical domains Script
extractKeywords Extract key concepts and terms from complex text Script
convertScientificLiterature Convert text to scientific literature format Script
geminiGrounding4R Advanced AI with Google Search grounding Script
textFileInput4ai Large-scale text file analysis with chunking Script
searchFunction Expert-level R function discovery and recommendation Script

💻 Additional Examples

Multi-LLM Execution via io.net

Execute multiple LLM models simultaneously for comprehensive AI responses across 23+ cutting-edge models.

# Set io.net API key
Sys.setenv(IONET_API_KEY = "your-ionet-api-key")

# Basic multi-LLM execution (Randomly selects 3 models)
result <- multiLLMviaionet(
  prompt = "Explain quantum computing",
  max_models = 3,
  random_selection = TRUE
)

# 📋 Explore available models (23+ total as of 2025)
all_models <- list_ionet_models()
print(paste("Total models available:", length(all_models)))

# 🏷️ Browse by category
llama_models <- list_ionet_models("llama")        # Meta Llama series (3 models)
deepseek_models <- list_ionet_models("deepseek")  # DeepSeek reasoning (4 models)  
qwen_models <- list_ionet_models("qwen")          # Alibaba Qwen series (2 models)
mistral_models <- list_ionet_models("mistral")    # Mistral AI series (4 models)
compact_models <- list_ionet_models("compact")    # Efficient models (4 models)
reasoning_models <- list_ionet_models("reasoning") # Math/logic specialists (2 models)

# 📊 Detailed model information
detailed_info <- list_ionet_models(detailed = TRUE)
View(detailed_info)

# 🚀 Advanced usage with custom parameters
result <- multiLLMviaionet(
  prompt = "Design a machine learning pipeline for time series forecasting",
  max_models = 8,
  streaming = FALSE,
  random_selection = TRUE,
  max_tokens = 2000,
  temperature = 0.3,        # More deterministic for technical tasks
  parallel = TRUE,          # True async execution
  verbose = TRUE           # Monitor progress
)

# Access comprehensive results
print(result$summary)                    # Execution statistics
lapply(result$results, function(x) {     # Individual model responses
  if(x$success) cat(x$model, ":", substr(x$response, 1, 200), "...\n\n")
})

🔥 Featured Models (2025):

📈 What's New

🐧 Version 1.1.0 (October 2025) - Linux Installation Fix

Breaking Change for Better Compatibility:

CI/CD Integration:

Installation Improvements:

Impact:

📊 Version 1.0.0 (January 2025) - Security & Multi-LLM

🔒 Security Enhancements

🚀 New Multi-LLM Capabilities

🛠️ Developer Experience

📊 Function Categories

License

Copyright (c) 2025 Satoshi Kume. Released under the Artistic License 2.0.

Cite

Kume S. (2025) chatAI4R: Chat-based Interactive Artificial Intelligence for R. Version 1.1.0.

#BibTeX
@misc{Kume2025chatAI4R,
  title={chatAI4R: Chat-Based Interactive Artificial Intelligence for R},
  author={Kume, Satoshi},
  year={2026},
  version={1.3.1},
  publisher={GitHub},
  note={R Package with Multi-LLM Capabilities},
  howpublished={\url{https://github.com/kumeS/chatAI4R}},
}

Contributors