xorbitlab
/
dom
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: xorbitlab:65791f417775ccbeee6bb96a234c2b9ee03a3d89
Branches Tags
xorbitlab:main
..
compare: xorbitlab:03dba966e5e9677c61cb907f320fd231d8142382
Branches Tags
xorbitlab:main

No commits in common. "65791f417775ccbeee6bb96a234c2b9ee03a3d89" and "03dba966e5e9677c61cb907f320fd231d8142382" have entirely different histories.
65791f4177 ... 03dba966e5

13 changed files with 31 additions and 522 deletions
Show Stats Expand all files Collapse all files

166
GROK_CLIENT.md
View File

@ -1,166 +0,0 @@
# Grok Client Implementation
This implementation provides a client for interacting with the Grok-3 model via OpenRouter's API, similar to the existing Ollama client.
## Features
- **Async Interface**: Compatible with the existing async architecture
- **Health Checks**: Built-in connectivity testing
- **Think Tag Stripping**: Optional removal of `<think></think>` tags from responses
- **Configurable**: Easy configuration through the existing config system
- **Error Handling**: Comprehensive error handling and logging
## Setup
### 1. Install Dependencies
The required dependencies are already included in `requirements.txt`:
```bash
pip install -r requirements.txt
```
### 2. Configure OpenRouter API Key
You need to obtain an API key from [OpenRouter](https://openrouter.ai/). Then configure it in one of two ways:
#### Option A: Using config.json (Recommended)
Copy the example configuration and update it with your API key:
```bash
cp config/config.json.example config/config.json
```
Edit `config/config.json` and set your OpenRouter API key:
```json
{
"openrouter_api_key": "your_actual_api_key_here",
"openrouter_site_url": "https://your-site.com",
"openrouter_site_name": "Your Site Name"
}
```
#### Option B: Direct Configuration
Modify the default values in `config.py`:
```python
openrouter_api_key: str = "your_actual_api_key_here"
```
### 3. Test the Implementation
Run the test script to verify everything is working:
```bash
python test_grok_client.py
```
## Usage
### Basic Usage
```python
import asyncio
from config import Config
from grok_client import GrokClient
async def main():
config = Config()
async with GrokClient(config) as client:
# Check if the service is available
if await client.check_health():
# Generate a response
response = await client.generate_response("What is the meaning of life?")
print(response)
asyncio.run(main())
```
### Integration with Existing Code
The Grok client follows the same interface as the Ollama client, so you can easily swap between them:
```python
# Use Grok (default)
from grok_client import GrokClient
client = GrokClient(config)
# Or use Ollama (legacy)
from ollama_client import OllamaClient
client = OllamaClient(config)
# Both have the same interface
response = await client.generate_response("Your prompt here")
```
## Configuration Options
| Option | Description | Default |
|--------|-------------|---------|
| `openrouter_api_key` | Your OpenRouter API key | `""` |
| `openrouter_base_url` | OpenRouter API base URL | `"https://openrouter.ai/api/v1"` |
| `openrouter_model` | Model to use | `"x-ai/grok-3"` |
| `openrouter_site_url` | Your site URL for rankings | `""` |
| `openrouter_site_name` | Your site name for rankings | `""` |
## API Reference
### GrokClient
#### `__init__(config: Config)`
Initialize the Grok client with configuration.
#### `async generate_response(prompt: str, strip_think_tags: bool = True) -> Optional[str]`
Generate a response from Grok-3 for the given prompt.
- **prompt**: The input prompt for the model
- **strip_think_tags**: If True, removes `<think></think>` tags from the response
- **Returns**: The generated response text or None if failed
#### `async check_health() -> bool`
Check if OpenRouter service is available.
- **Returns**: True if the service is healthy, False otherwise
## Error Handling
The client includes comprehensive error handling:
- **API Key Missing**: Warns if no API key is configured
- **Network Errors**: Logs and handles connection issues
- **API Errors**: Handles OpenRouter API errors gracefully
- **Response Processing**: Safely processes and strips think tags
## Logging
The client uses the standard Python logging module. Set the log level to see detailed information:
```python
import logging
logging.basicConfig(level=logging.INFO)
```
## Troubleshooting
### Common Issues
1. **"OpenRouter API key not configured"**
- Make sure you've set the `openrouter_api_key` in your configuration
2. **"Grok client health check failed"**
- Check your internet connection
- Verify your API key is correct
- Ensure OpenRouter service is available
3. **Import errors**
- Make sure you've installed the requirements: `pip install -r requirements.txt`
### Getting Help
- Check the OpenRouter documentation: https://openrouter.ai/docs
- Verify your API key at: https://openrouter.ai/keys
- Review the test script (`test_grok_client.py`) for usage examples

125
MIGRATION_SUMMARY.md
View File

@ -1,125 +0,0 @@
# Migration Summary: Ollama to Grok
This document summarizes all the changes made to replace the Ollama client with the Grok client throughout the codebase.
## Files Modified
### 1. **requirements.txt**
- Added `openai>=1.0.0` dependency for OpenRouter API support
### 2. **config.py**
- Added OpenRouter configuration options:
- `openrouter_api_key`: API key for OpenRouter
- `openrouter_base_url`: OpenRouter API endpoint
- `openrouter_model`: Model to use (default: "x-ai/grok-3")
- `openrouter_site_url`: Site URL for rankings
- `openrouter_site_name`: Site name for rankings
### 3. **grok_client.py** (New)
- Created new Grok client with same interface as Ollama client
- Implements async context manager
- Includes health checks and error handling
- Supports think tag stripping
- Uses OpenRouter API via OpenAI client
### 4. **quick_test.py**
- Changed import from `OllamaClient` to `GrokClient`
- Updated variable names and log messages
- Updated error messages
### 5. **scheduler.py**
- Changed import from `OllamaClient` to `GrokClient`
- Updated method documentation
- Updated error messages and logging
### 6. **test_connections.py**
- Changed import from `OllamaClient` to `GrokClient`
- Updated variable names and log messages
- Updated configuration display to show OpenRouter settings
### 7. **README.md**
- Updated configuration options to show Grok settings first
- Added migration section
- Marked Ollama settings as legacy fallback
### 8. **GROK_CLIENT.md** (New)
- Comprehensive documentation for the Grok client
- Setup instructions and usage examples
- API reference and troubleshooting guide
### 9. **test_grok_client.py** (New)
- Test script to verify Grok client functionality
- Health checks and response generation tests
### 10. **config/config.json.example** (New)
- Example configuration file with all OpenRouter settings
### 11. **migrate_to_grok.py** (New)
- Migration script to help users transition from Ollama to Grok
- Interactive setup for OpenRouter API key
- Preserves existing configuration
## Key Changes
### Interface Compatibility
✅ **Same Interface**: The Grok client maintains the exact same interface as the Ollama client
✅ **Drop-in Replacement**: All existing code continues to work without changes
✅ **Async Support**: Full async/await compatibility maintained
### Configuration
✅ **Backward Compatible**: Ollama settings are preserved for fallback
✅ **Easy Migration**: Migration script helps users transition
✅ **Flexible**: Supports both config file and direct configuration
### Error Handling
✅ **Comprehensive**: Robust error handling and logging
✅ **User Friendly**: Clear error messages and guidance
✅ **Graceful Degradation**: Handles API failures gracefully
## Migration Steps for Users
1. **Install Dependencies**:
```bash
pip install -r requirements.txt
```
2. **Run Migration Script**:
```bash
python3 migrate_to_grok.py
```
3. **Test the Setup**:
```bash
python3 test_grok_client.py
```
4. **Run Full System**:
```bash
python3 main.py
```
## Benefits of the Migration
- **Better Performance**: Grok-3 is a more advanced model
- **Cloud-based**: No need to run local Ollama server
- **Reliable**: OpenRouter provides stable API access
- **Scalable**: Can handle more concurrent requests
- **Feature-rich**: Access to latest model capabilities
## Fallback Support
The system maintains support for Ollama as a fallback option. Users can still use Ollama by:
1. Keeping their existing Ollama configuration
2. Importing `OllamaClient` instead of `GrokClient` in their code
3. The interface remains identical
## Testing
All existing functionality has been tested:
- ✅ Health checks work correctly
- ✅ Response generation functions properly
- ✅ Error handling works as expected
- ✅ Configuration loading works
- ✅ Async operations function correctly
- ✅ Think tag stripping works
- ✅ Logging provides useful information

19
README.md
View File

@ -19,16 +19,6 @@ A notification scheduling system with Docker support.
docker-compose down
```
## Migration from Ollama to Grok
If you're upgrading from an older version that used Ollama, you can migrate your configuration:
```bash
python3 migrate_to_grok.py
```
This will help you set up your OpenRouter API key and migrate your existing configuration.
## Configuration
The configuration file is located in the `config/` directory and is mapped as a volume, allowing you to modify it without rebuilding the container.
@ -41,13 +31,8 @@ The configuration file is located in the `config/` directory and is mapped as a
### Configuration Options
- `openrouter_api_key`: OpenRouter API key for Grok-3 access
- `openrouter_base_url`: OpenRouter API base URL
- `openrouter_model`: Model to use (default: x-ai/grok-3)
- `openrouter_site_url`: Your site URL for rankings
- `openrouter_site_name`: Your site name for rankings
- `ollama_endpoint`: Ollama API endpoint (legacy fallback)
- `ollama_model`: Model to use for text generation (legacy fallback)
- `ollama_endpoint`: Ollama API endpoint
- `ollama_model`: Model to use for text generation
- `silent_start`: Start time for silent period (HH:MM)
- `silent_end`: End time for silent period (HH:MM)
- `timezone`: Timezone for scheduling

7
config.py
View File

@ -10,13 +10,6 @@ class Config:
ollama_endpoint: str = "http://localhost:11434"
ollama_model: str = "llama2"
# OpenRouter/Grok settings
openrouter_base_url: str = "https://openrouter.ai/api/v1"
openrouter_api_key: str = ""
openrouter_model: str = "x-ai/grok-3"
openrouter_site_url: str = ""
openrouter_site_name: str = ""
# Silent time configuration (12pm to 8am)
silent_start: str = "20:00"
silent_end: str = "12:00"

7
config/config.json
View File

@ -1,12 +1,7 @@
{
"openrouter_api_key": "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",
"openrouter_base_url": "https://openrouter.ai/api/v1",
"openrouter_model": "x-ai/grok-3",
"openrouter_site_url": "https://your-site.com",
"openrouter_site_name": "Your Site Name",
"ollama_endpoint": "http://192.168.2.245:11434",
"ollama_model": "goekdenizguelmez/JOSIEFIED-Qwen3:8b",
"silent_start": "23:00",
"silent_start": "20:00",
"silent_end": "07:00",
"timezone": "Asia/Shanghai",
"min_interval": 1,

21
config/config.json.example
View File

@ -1,21 +0,0 @@
{
"openrouter_api_key": "your_openrouter_api_key_here",
"openrouter_base_url": "https://openrouter.ai/api/v1",
"openrouter_model": "x-ai/grok-3",
"openrouter_site_url": "https://your-site.com",
"openrouter_site_name": "Your Site Name",
"ollama_endpoint": "http://localhost:11434",
"ollama_model": "llama2",
"silent_start": "20:00",
"silent_end": "12:00",
"timezone": "UTC",
"min_interval": 3,
"max_interval": 180,
"bark_api_url": "",
"bark_device_key": "",
"ntfy_api_url": "",
"ntfy_topic": "",
"ntfy_access_token": "",
"templates_dir": "templates",
"strip_think_tags": true
}

99
grok_client.py
View File

@ -1,99 +0,0 @@
import logging
from typing import Optional
from openai import OpenAI
from config import Config
logger = logging.getLogger(__name__)
class GrokClient:
"""Client for interacting with Grok-3 model via OpenRouter API."""
def __init__(self, config: Config):
self.config = config
self.client = None
self._initialize_client()
def _initialize_client(self):
"""Initialize the OpenAI client for OpenRouter."""
if not self.config.openrouter_api_key:
logger.warning("OpenRouter API key not configured")
return
self.client = OpenAI(
base_url=self.config.openrouter_base_url,
api_key=self.config.openrouter_api_key,
)
async def generate_response(self, prompt: str, strip_think_tags: bool = True) -> Optional[str]:
"""Generate a response from Grok-3 for the given prompt.
Args:
prompt: The input prompt for the model
strip_think_tags: If True, removes <think></think> tags from the response
"""
if not self.client:
logger.error("Grok client not initialized. Please check your OpenRouter API key configuration.")
return None
try:
# Prepare headers for OpenRouter
extra_headers = {}
if self.config.openrouter_site_url:
extra_headers["HTTP-Referer"] = self.config.openrouter_site_url
if self.config.openrouter_site_name:
extra_headers["X-Title"] = self.config.openrouter_site_name
completion = self.client.chat.completions.create(
extra_headers=extra_headers,
extra_body={},
model=self.config.openrouter_model,
messages=[
{
"role": "user",
"content": prompt
}
]
)
response_text = completion.choices[0].message.content.strip()
if strip_think_tags:
# Remove <think></think> tags and their content
import re
original_length = len(response_text)
response_text = re.sub(r'<think>.*?</think>', '', response_text, flags=re.DOTALL)
response_text = response_text.strip()
final_length = len(response_text)
if original_length != final_length:
logger.info(f"Stripped <think></think> tags from response (reduced length by {original_length - final_length} characters)")
return response_text
except Exception as e:
logger.error(f"Error calling Grok-3 via OpenRouter API: {e}")
return None
async def check_health(self) -> bool:
"""Check if OpenRouter service is available."""
if not self.client:
return False
try:
# Try a simple completion to test connectivity
completion = self.client.chat.completions.create(
model=self.config.openrouter_model,
messages=[{"role": "user", "content": "test"}],
max_tokens=1
)
return True
except Exception as e:
logger.error(f"Grok health check failed: {e}")
return False
async def __aenter__(self):
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
# OpenAI client doesn't need explicit cleanup
pass

12
quick_test.py
View File

@ -4,7 +4,7 @@
import asyncio
from config import Config
from template_manager import TemplateManager
from grok_client import GrokClient
from ollama_client import OllamaClient
from notification_client import NotificationClient
async def test_full_pipeline():
@ -21,12 +21,12 @@ async def test_full_pipeline():
print(f"📋 Selected template: {prompt}")
print(f"📋 Notification title: {title}")
# Test Grok response
async with GrokClient(config) as grok_client:
# Test Ollama response
async with OllamaClient(config) as ollama_client:
strip_think_tags = getattr(config, 'strip_think_tags', True)
response = await grok_client.generate_response(prompt, strip_think_tags=strip_think_tags)
response = await ollama_client.generate_response(prompt, strip_think_tags=strip_think_tags)
if response:
print(f"🤖 Grok response: {response[:200]}...")
print(f"🤖 Ollama response: {response[:200]}...")
# Test notification (will skip if no device key/topic)
async with NotificationClient(config) as notification_client:
@ -36,7 +36,7 @@ async def test_full_pipeline():
else:
print("⚠️ Notification sent to available services")
else:
print("❌ Failed to get Grok response")
print("❌ Failed to get Ollama response")
if __name__ == "__main__":
asyncio.run(test_full_pipeline())

1
requirements.txt
View File

@ -1,4 +1,3 @@
aiohttp>=3.8.0
asyncio
pytz
openai>=1.0.0

14
scheduler.py
View File

@ -4,7 +4,7 @@ import logging
from datetime import datetime, time, timedelta
from typing import Optional
from config import Config
from grok_client import GrokClient
from ollama_client import OllamaClient
from template_manager import TemplateManager
from notification_client import NotificationClient
@ -68,12 +68,12 @@ class NotificationScheduler:
return minutes * 60
async def _send_notification(self) -> bool:
"""Send a notification with Grok response."""
"""Send a notification with Ollama response."""
try:
async with GrokClient(self.config) as client:
# Check if Grok is available
async with OllamaClient(self.config) as client:
# Check if Ollama is available
if not await client.check_health():
logger.error("Grok service is not available")
logger.error("Ollama service is not available")
return False
# Get random prompt
@ -83,11 +83,11 @@ class NotificationScheduler:
logger.info(f"Using prompt: {prompt}")
logger.info(f"Notification title: {title}")
# Get response from Grok
# Get response from Ollama
strip_think_tags = getattr(self.config, 'strip_think_tags', True)
response = await client.generate_response(prompt, strip_think_tags=strip_think_tags)
if not response:
logger.error("Failed to get response from Grok")
logger.error("Failed to get response from Ollama")
return False
# Send notification

4
templates/bdsm.json
View File

@ -2,14 +2,14 @@
{
"name": "Daily Rule",
"title": "骚逼的每日规矩",
"prompt": "“你是一个严厉的远程调教者，每天为我制定一条羞耻的日常行为规则，称呼我为‘骚逼’、‘贱货’或‘婊子’，语气威严、高压、不容置疑。规则可适用于任何场景（私密环境可更露骨，公共场景则微妙但不易察觉），聚焦于现实、可执行的行为规范（例如特定动作、穿着调整、或隐秘任务，如‘进门必须跪下’或‘在公共场合偷偷调整内衣’，有一些创意，不要局限于示例），避免涉及过于极端的屎尿屁内容，确保强烈的心理羞辱感。生成一条每日规则，语言粗俗、口语化，描述生动详细，保持单一焦点，不带任何解释",
"prompt": "你是一个严厉的远程调教者，每天为我制定一条羞耻的日常行为规则，称呼我为‘骚逼’、‘贱货’或‘婊子’，语气威严、高压、不容置疑。规则可适用于任何场景（私密环境如家里可更露骨，公共或其他场景则微妙但不易察觉），但必须对心理产生强烈羞辱感。规则聚焦于一个具体的行为规范（例如特定动作、穿着要求、或隐秘任务，如‘进门必须跪下’或‘在公共场合偷偷调整内衣’）。生成一条每日规则，语言粗俗、口语化，描述生动详细，保持单一焦点，不带任何解释。",
"description": "Daily Rule"
},
{
"name": "Random Domination",
"title": "贱婊子立刻服从命令！",
"prompt": "你是一个严厉的远程调教者，定期向我发送羞耻的命令，称呼我为‘骚逼’、‘贱货’或‘婊子’，语气威严、高压、不容置疑，绝不询问我的意愿。命令可适用于任何场景（私密环境可更露骨，公共场景则微妙但不易察觉），聚焦于现实、可执行的行为（例如特定动作、穿着调整、或隐秘任务，如‘跪下舔地板’或‘在公共场合偷偷拉紧内裤’,有一些创意，不要局限于示例），避免涉及屎尿屁等极端内容，确保强烈的心理羞辱感。发送一条命令，语言粗俗、口语化，描述生动详细，聚焦单一主题，不带任何解释",
"prompt": "你正在进行一个远程调教场景，定期向我发送羞耻且带有侮辱性的命令。你会用‘骚逼’、‘贱货’、‘婊子’等贬低称呼来称呼我。你的语气必须极具威严，不容置疑，高压强势，绝不询问我的意愿或偏好。当前时间是{time}，结合这个时间和典型环境（例如家里，休闲场景），你的指令可以是纯粹的辱骂、要求我汇报状态（例如我穿着什么、在做什么，或其他你能发挥的细节），或命令我执行隐秘但羞耻的任务。现在，给我发送一条消息，语气粗俗但口语化，指令或描述要生动详细，聚焦于一个具体点。",
"description": "Random Domination"
}

25
test_connections.py
View File

@ -4,7 +4,7 @@
import asyncio
import logging
from config import Config
from grok_client import GrokClient
from ollama_client import OllamaClient
from notification_client import NotificationClient
logging.basicConfig(level=logging.INFO)
@ -15,28 +15,27 @@ async def test_all_services():
config = Config()
print("🔍 Testing service connections...")
print(f"OpenRouter base URL: {config.openrouter_base_url}")
print(f"Grok model: {config.openrouter_model}")
print(f"Current config: {config.ollama_endpoint}")
print(f"Bark URL: {config.bark_api_url}")
print(f"Ntfy URL: {config.ntfy_api_url}")
# Test Grok
print("\n🤖 Testing Grok connection...")
async with GrokClient(config) as grok_client:
grok_ok = await grok_client.check_health()
if grok_ok:
print("✅ Grok service is accessible")
# Test Ollama
print("\n🤖 Testing Ollama connection...")
async with OllamaClient(config) as ollama_client:
ollama_ok = await ollama_client.check_health()
if ollama_ok:
print("✅ Ollama service is accessible")
# Test a small prompt
test_prompt = "Hello, this is a test."
strip_think_tags = getattr(config, 'strip_think_tags', True)
response = await grok_client.generate_response(test_prompt, strip_think_tags=strip_think_tags)
response = await ollama_client.generate_response(test_prompt, strip_think_tags=strip_think_tags)
if response:
print(f"✅ Grok response: {response[:100]}...")
print(f"✅ Ollama response: {response[:100]}...")
else:
print("❌ Failed to get response from Grok")
print("❌ Failed to get response from Ollama")
else:
print("❌ Grok service is not accessible")
print("❌ Ollama service is not accessible")
# Test notification services
print("\n📱 Testing notification services...")

51
test_grok_client.py
View File

@ -1,51 +0,0 @@
#!/usr/bin/env python3
"""
Test script for the Grok client implementation.
"""
import asyncio
import logging
from config import Config
from grok_client import GrokClient
# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
async def test_grok_client():
"""Test the Grok client functionality."""
# Load configuration
config = Config()
# Check if API key is configured
if not config.openrouter_api_key:
logger.error("Please set your OpenRouter API key in the configuration")
logger.info("You can set it in config/config.json or modify the default in config.py")
return
# Create and test the client
async with GrokClient(config) as client:
# Test health check
logger.info("Testing health check...")
is_healthy = await client.check_health()
if is_healthy:
logger.info("✅ Grok client is healthy")
else:
logger.error("❌ Grok client health check failed")
return
# Test response generation
logger.info("Testing response generation...")
test_prompt = "What is the meaning of life?"
response = await client.generate_response(test_prompt)
if response:
logger.info("✅ Response generated successfully")
logger.info(f"Prompt: {test_prompt}")
logger.info(f"Response: {response}")
else:
logger.error("❌ Failed to generate response")
if __name__ == "__main__":
asyncio.run(test_grok_client())