rdai 1.0.0__tar.gz

rdai-1.0.0/.gitignore

@@ -0,0 +1,17 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+.ruff_cache/
+.coverage
+coverage.xml
+htmlcov/
+.venv/
+venv/
+dist/
+build/
+*.egg-info/
+
+# Local provider credentials
+.env
+

rdai-1.0.0/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2026 Ranajit Dhar
+Website: https://ranajitdhar.in
+Email: contact@ranajitdhar.in
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rdai-1.0.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: rdai
+Version: 1.0.0
+Summary: One interface for resilient, multi-provider AI generation.
+Project-URL: Homepage, https://github.com/ranajitdhar/rdai
+Project-URL: Repository, https://github.com/ranajitdhar/rdai
+Project-URL: Issues, https://github.com/ranajitdhar/rdai/issues
+Author: Ranajit Dhar
+License: MIT
+License-File: LICENSE
+Keywords: ai,cli,failover,gemini,groq,llm,openai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: groq>=0.11.0
+Requires-Dist: openai>=1.54.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: rich>=13.9.0
+Requires-Dist: typer>=0.12.5
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.0; extra == 'dev'
+Requires-Dist: ruff>=0.8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<div align="center">
+  <pre>
+██████╗ ██████╗  █████╗ ██╗
+██╔══██╗██╔══██╗██╔══██╗██║
+██████╔╝██║  ██║███████║██║
+██╔══██╗██║  ██║██╔══██║██║
+██║  ██║██████╔╝██║  ██║██║
+╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝╚═╝
+  </pre>
+</div>
+
+# 🚀 rdai (Ranajit Dhar AI) - Multi-Brain AI Orchestrator
+
+> **One Interface. Any AI. Unbreakable Auto-Failover.**
+
+**Version:** v1.0.0  
+**👑 Created by:** Ranajit Dhar  
+**🌐 Website:** [https://ranajitdhar.in](https://ranajitdhar.in)
+
+`rdai` is a Quantum-Ready, Self-Healing AI Operating System and Python SDK. It allows you to call multiple AI models (Gemini, OpenAI, Claude, DeepSeek, and more) through one single, unified interface. It automatically discovers your API keys, selects the best provider based on your strategy, and features a limitless **Circuit Breaker** that silently auto-failovers to a backup provider when rate limits, crashes, or timeouts occur. 
+
+Zero downtime. 100% Reliability.
+
+---
+
+## ✨ Key Features
+
+*   🧠 **11+ Built-in AI Brains:** Native support for Gemini, OpenAI, Groq, Claude, DeepSeek, Qwen, Llama, Mistral, VertexAI, AWS Bedrock, and HuggingFace.
+*   ⚡ **Unbreakable Auto-Failover:** If your primary model crashes or hits a rate limit, the system instantly and silently routes the prompt to the next available model.
+*   🛠️ **Bring-Your-Own-Model (BYOM):** Inject any custom/private AI API into the failover chain without changing the core framework.
+*   🩺 **Live Ping Diagnostics:** The built-in CLI doctor actually pings the AI servers to report real-time ALIVE/ERROR status and latency.
+*   🪄 **Smart Auto-Setup:** Automatically installs missing required SDKs in the background during initialization. Prevents accidental configuration overwrites.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install rdai
+# Or if using local source: pip install -r requirements.txt
+```
+---
+## 🚦 Quick Start (The CLI Wizard)
+
+`rdai` comes with a powerful CLI dashboard. To configure your multi-brain environment, simply run:
+
+```bash
+rdai init
+```
+
+This interactive wizard will let you select your AI providers, define your failover strategy, auto-install missing packages, and generate your `.env` and `rdai.yaml` files.  
+
+Next, add your API keys to the generated `.env` file:Code snippet
+
+```env
+GEMINI_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+OPENAI_API_KEY=your_key_here
+# Add others as selected...
+```
+**(Note: Your API keys are kept strictly local and secure. They are never hardcoded.)**
+
+Finally, verify your setup with the live diagnostic tool:
+
+```bash
+rdai doctor
+```
+The doctor will scan your `.env` file, ping the AI networks, and show you the real-time latency and health of your failover chain.
+
+---
+
+## 💻 Python SDK Usage (Writing Code)
+
+Using the SDK is incredibly simple. You don't need to learn 10 different SDKs; rdai standardizes everything.
+
+```python
+from rdai import AI
+
+# Initialize the AI Engine. It automatically loads your rdai.yaml strategy.
+ai = AI()
+
+# Send a prompt. If the first model fails, it silently falls back to the next!
+response = ai.generate("Write a multi-agent orchestration script in Python.")
+print(response)
+```
+
+# Bring Your Own Model (BYOM)
+
+Want to use a custom API? Inject it directly into the engine:
+
+```python
+from rdai.providers.base import BaseProvider
+from rdai import AI
+import requests
+
+class CustomNexusProvider(BaseProvider):
+    def __init__(self, api_key):
+        super().__init__(api_key, "nexus-v1")
+        
+    def generate(self, prompt: str, **kwargs) -> str:
+        res = requests.post("[https://api.nexus.com/v1](https://api.nexus.com/v1)", headers={"Key": self.api_key}, json={"text": prompt})
+        return res.json()["reply"]
+
+# Inject your custom engine into the failover chain!
+ai = AI(providers=[CustomNexusProvider(api_key="your_custom_key")])
+print(ai.generate("Hello Custom Engine!"))
+```
+
+---
+
+## ⚙️ Routing Strategies & Configuration
+
+`rdai` reads your setup from an optional `rdai.yaml` file in the current directory. Environment variables take precedence over values in `.env`
+
+```yaml
+strategy: smart
+provider_order:
+  - gemini
+  - openai
+  - groq
+```
+
+---
+
+### 🧠 Routing Strategies
+
+*   **`smart`**: Selects a ready provider whose traits best fit the specific request.
+*   **`manual`**: Strictly follows the exact `provider_order` defined in your `rdai.yaml`.
+
+> **Note:** Both strategies retain the remaining ready providers as automatic fallbacks for transient rate-limit and timeout failures.
+
+---
+
+## 🎛️ Supported AI Engines & Environment Keys
+
+| Provider Engine | Environment Variable | Backend Logic |
+| :--- | :--- | :--- |
+| **Gemini** | `GEMINI_API_KEY` | Modern `google.genai` SDK |
+| **OpenAI** | `OPENAI_API_KEY` | Official `openai` SDK |
+| **Groq** | `GROQ_API_KEY` | Official `groq` SDK |
+| **VertexAI** | `VERTEXAI_API_KEY` | GCP Project ID via `google.genai` |
+| **Claude** | `CLAUDE_API_KEY` | Direct Anthropic REST API |
+| **AWS Bedrock** | `AWS_BEDROCK_API_KEY` | AWS `boto3` SDK |
+| **DeepSeek** | `DEEPSEEK_API_KEY` | Direct DeepSeek REST API |
+| **Qwen** | `QWEN_API_KEY` | Alibaba DashScope REST API |
+| **Llama** | `LLAMA_API_KEY` | Universal OpenAI-Compatible API |
+| **Mistral** | `MISTRAL_API_KEY` | Direct Mistral REST API |
+| **HuggingFace** | `HUGGINGFACE_API_KEY` | HF Serverless Inference API |
+
+
+---
+
+## 🛠️ Complete CLI Command Reference
+
+*   `rdai init` - Setup your workspace, strategies, and AI providers.
+*   `rdai doctor` - Run a live `.env` network scan and API health check.
+*   `rdai config` - View your active routing strategy and failover chain.
+*   `rdai benchmark` - Run a latency test across your active models.
+*   `rdai health` - Check overall internal system health and readiness.
+*   `rdai about` - Learn about the master orchestration architecture.
+
+---
+<div align="center">
+  <i>Built with ❤️ for the next generation of unbreakable AI applications.</i>
+</div>

rdai-1.0.0/README.md

@@ -0,0 +1,165 @@
+<div align="center">
+  <pre>
+██████╗ ██████╗  █████╗ ██╗
+██╔══██╗██╔══██╗██╔══██╗██║
+██████╔╝██║  ██║███████║██║
+██╔══██╗██║  ██║██╔══██║██║
+██║  ██║██████╔╝██║  ██║██║
+╚═╝  ╚═╝╚═════╝ ╚═╝  ╚═╝╚═╝
+  </pre>
+</div>
+
+# 🚀 rdai (Ranajit Dhar AI) - Multi-Brain AI Orchestrator
+
+> **One Interface. Any AI. Unbreakable Auto-Failover.**
+
+**Version:** v1.0.0  
+**👑 Created by:** Ranajit Dhar  
+**🌐 Website:** [https://ranajitdhar.in](https://ranajitdhar.in)
+
+`rdai` is a Quantum-Ready, Self-Healing AI Operating System and Python SDK. It allows you to call multiple AI models (Gemini, OpenAI, Claude, DeepSeek, and more) through one single, unified interface. It automatically discovers your API keys, selects the best provider based on your strategy, and features a limitless **Circuit Breaker** that silently auto-failovers to a backup provider when rate limits, crashes, or timeouts occur. 
+
+Zero downtime. 100% Reliability.
+
+---
+
+## ✨ Key Features
+
+*   🧠 **11+ Built-in AI Brains:** Native support for Gemini, OpenAI, Groq, Claude, DeepSeek, Qwen, Llama, Mistral, VertexAI, AWS Bedrock, and HuggingFace.
+*   ⚡ **Unbreakable Auto-Failover:** If your primary model crashes or hits a rate limit, the system instantly and silently routes the prompt to the next available model.
+*   🛠️ **Bring-Your-Own-Model (BYOM):** Inject any custom/private AI API into the failover chain without changing the core framework.
+*   🩺 **Live Ping Diagnostics:** The built-in CLI doctor actually pings the AI servers to report real-time ALIVE/ERROR status and latency.
+*   🪄 **Smart Auto-Setup:** Automatically installs missing required SDKs in the background during initialization. Prevents accidental configuration overwrites.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install rdai
+# Or if using local source: pip install -r requirements.txt
+```
+---
+## 🚦 Quick Start (The CLI Wizard)
+
+`rdai` comes with a powerful CLI dashboard. To configure your multi-brain environment, simply run:
+
+```bash
+rdai init
+```
+
+This interactive wizard will let you select your AI providers, define your failover strategy, auto-install missing packages, and generate your `.env` and `rdai.yaml` files.  
+
+Next, add your API keys to the generated `.env` file:Code snippet
+
+```env
+GEMINI_API_KEY=your_key_here
+GROQ_API_KEY=your_key_here
+OPENAI_API_KEY=your_key_here
+# Add others as selected...
+```
+**(Note: Your API keys are kept strictly local and secure. They are never hardcoded.)**
+
+Finally, verify your setup with the live diagnostic tool:
+
+```bash
+rdai doctor
+```
+The doctor will scan your `.env` file, ping the AI networks, and show you the real-time latency and health of your failover chain.
+
+---
+
+## 💻 Python SDK Usage (Writing Code)
+
+Using the SDK is incredibly simple. You don't need to learn 10 different SDKs; rdai standardizes everything.
+
+```python
+from rdai import AI
+
+# Initialize the AI Engine. It automatically loads your rdai.yaml strategy.
+ai = AI()
+
+# Send a prompt. If the first model fails, it silently falls back to the next!
+response = ai.generate("Write a multi-agent orchestration script in Python.")
+print(response)
+```
+
+# Bring Your Own Model (BYOM)
+
+Want to use a custom API? Inject it directly into the engine:
+
+```python
+from rdai.providers.base import BaseProvider
+from rdai import AI
+import requests
+
+class CustomNexusProvider(BaseProvider):
+    def __init__(self, api_key):
+        super().__init__(api_key, "nexus-v1")
+        
+    def generate(self, prompt: str, **kwargs) -> str:
+        res = requests.post("[https://api.nexus.com/v1](https://api.nexus.com/v1)", headers={"Key": self.api_key}, json={"text": prompt})
+        return res.json()["reply"]
+
+# Inject your custom engine into the failover chain!
+ai = AI(providers=[CustomNexusProvider(api_key="your_custom_key")])
+print(ai.generate("Hello Custom Engine!"))
+```
+
+---
+
+## ⚙️ Routing Strategies & Configuration
+
+`rdai` reads your setup from an optional `rdai.yaml` file in the current directory. Environment variables take precedence over values in `.env`
+
+```yaml
+strategy: smart
+provider_order:
+  - gemini
+  - openai
+  - groq
+```
+
+---
+
+### 🧠 Routing Strategies
+
+*   **`smart`**: Selects a ready provider whose traits best fit the specific request.
+*   **`manual`**: Strictly follows the exact `provider_order` defined in your `rdai.yaml`.
+
+> **Note:** Both strategies retain the remaining ready providers as automatic fallbacks for transient rate-limit and timeout failures.
+
+---
+
+## 🎛️ Supported AI Engines & Environment Keys
+
+| Provider Engine | Environment Variable | Backend Logic |
+| :--- | :--- | :--- |
+| **Gemini** | `GEMINI_API_KEY` | Modern `google.genai` SDK |
+| **OpenAI** | `OPENAI_API_KEY` | Official `openai` SDK |
+| **Groq** | `GROQ_API_KEY` | Official `groq` SDK |
+| **VertexAI** | `VERTEXAI_API_KEY` | GCP Project ID via `google.genai` |
+| **Claude** | `CLAUDE_API_KEY` | Direct Anthropic REST API |
+| **AWS Bedrock** | `AWS_BEDROCK_API_KEY` | AWS `boto3` SDK |
+| **DeepSeek** | `DEEPSEEK_API_KEY` | Direct DeepSeek REST API |
+| **Qwen** | `QWEN_API_KEY` | Alibaba DashScope REST API |
+| **Llama** | `LLAMA_API_KEY` | Universal OpenAI-Compatible API |
+| **Mistral** | `MISTRAL_API_KEY` | Direct Mistral REST API |
+| **HuggingFace** | `HUGGINGFACE_API_KEY` | HF Serverless Inference API |
+
+
+---
+
+## 🛠️ Complete CLI Command Reference
+
+*   `rdai init` - Setup your workspace, strategies, and AI providers.
+*   `rdai doctor` - Run a live `.env` network scan and API health check.
+*   `rdai config` - View your active routing strategy and failover chain.
+*   `rdai benchmark` - Run a latency test across your active models.
+*   `rdai health` - Check overall internal system health and readiness.
+*   `rdai about` - Learn about the master orchestration architecture.
+
+---
+<div align="center">
+  <i>Built with ❤️ for the next generation of unbreakable AI applications.</i>
+</div>

rdai-1.0.0/examples/basic_chat.py

@@ -0,0 +1,16 @@
+"""Minimal rdai SDK example.
+
+Run after adding at least one API key to a local .env file.
+"""
+
+from rdai import AI
+
+
+def main() -> None:
+    ai = AI(strategy="smart")
+    print(ai.generate("Explain dependency inversion in two sentences."))
+
+
+if __name__ == "__main__":
+    main()
+

rdai-1.0.0/examples/custom_brain.py

@@ -0,0 +1,23 @@
+from rdai.providers.base import BaseProvider
+from rdai import AI
+import requests
+
+# User tar nijer private ba notun custom provider banacche
+class NexusCustomProvider(BaseProvider):
+    traits = ["reasoning", "proprietary"]
+    
+    def __init__(self, api_key=None, model="nexus-v1-pro"):
+        super().__init__(api_key, model)
+
+    @property
+    def is_available(self) -> bool:
+        return bool(self.api_key)
+
+    def generate(self, prompt: str, **kwargs) -> str:
+        # Custom API logic here...
+        # Example: res = requests.post("https://api.nexus.com/v1", ...)
+        return f"[NexusAI] Simulated response for: {prompt}"
+
+# Nijer AI instance e inject kore dilo!
+ai = AI(strategy="manual", providers=[NexusCustomProvider(api_key="secret_key")])
+print(ai.generate("How to structure a Next.js app?"))

rdai-1.0.0/examples/smart_failover.py

@@ -0,0 +1,15 @@
+"""Route a coding request, while retaining automatic provider failover."""
+
+from rdai import AI
+
+
+def main() -> None:
+    ai = AI(strategy="smart")
+    answer = ai.generate(
+        "Write a typed Python function that retries an asynchronous operation.",
+    )
+    print(answer)
+
+
+if __name__ == "__main__":
+    main()

rdai-1.0.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "rdai"
+version = "1.0.0"
+description = "One interface for resilient, multi-provider AI generation."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Ranajit Dhar" },
+]
+keywords = ["ai", "llm", "cli", "failover", "gemini", "groq", "openai"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+  "google-genai>=1.0.0",
+  "groq>=0.11.0",
+  "openai>=1.54.0",
+  "python-dotenv>=1.0.1",
+  "PyYAML>=6.0.2",
+  "questionary>=2.0.1",
+  "rich>=13.9.0",
+  "typer>=0.12.5",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8.3.0",
+  "pytest-cov>=5.0.0",
+  "ruff>=0.8.0",
+]
+
+[project.scripts]
+rdai = "rdai.cli.main:app"
+
+[project.urls]
+Homepage = "https://github.com/ranajitdhar/rdai"
+Repository = "https://github.com/ranajitdhar/rdai"
+Issues = "https://github.com/ranajitdhar/rdai/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["rdai"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+