Iyeoluwads/ds_zagres_ai
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fixed team chats

Browse Source
This commit is contained in:
Iyeoluwa Akinrinola
2025-05-16 18:03:15 +01:00
parent 463923278a
commit 730009ae87
21 changed files with 1655 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
LOCAL_TESTING_README.md
+160
View File
@@ -0,0 +1,160 @@
# Local Testing with Remote Server Resources
This guide explains how to set up local testing that connects to remote server resources for the chatbot project.
## Overview
These scripts allow you to:
1. Test the connection to the remote Ollama server
2. Create SSH tunnels to access remote resources locally
3. Run tests against the remote Ollama models from your local machine
## Setup Instructions
### 1. Initial Setup
Run the setup script to create a virtual environment and install dependencies:
```bash
chmod +x setup_local_test_env.sh
./setup_local_test_env.sh
```
This will:
- Create a Python virtual environment
- Install required dependencies
- Create a `local_test.env` file from the template
### 2. Configure Environment Variables
Edit the `local_test.env` file with your server credentials:
```bash
# Remote server configuration
SERVER_IP=104.225.217.215
SERVER_PORT=22
SERVER_USER=root
SERVER_PASSWORD=your_password_here # Add your actual password
# Ollama configuration
OLLAMA_API_URL=http://104.225.217.215:11434
# OpenWebUI configuration
OPENWEBUI_URL=http://104.225.217.215:8080
OPENWEBUI_API_KEY=your_openwebui_api_key_here
```
### 3. Create SSH Tunnels (Optional)
If you want to access the remote resources through localhost (recommended for security and to avoid firewall issues), create SSH tunnels:
```bash
chmod +x create_ssh_tunnel.sh
./create_ssh_tunnel.sh
```
This will create SSH tunnels for:
- Ollama API (localhost:11434 → remote:11434)
- OpenWebUI (localhost:8080 → remote:8080)
If you use SSH tunnels, update your `local_test.env` file to use localhost URLs:
```bash
# Ollama configuration
OLLAMA_API_URL=http://localhost:11434
# OpenWebUI configuration
OPENWEBUI_URL=http://localhost:8080
```
### 4. Run Tests
Activate the virtual environment and run the test script:
```bash
source venv/bin/activate
python test_remote_ollama.py
```
#### Test Options
You can customize the test with command-line arguments:
```bash
# Test with a specific model
python test_remote_ollama.py --model llama3.3
# Test with a custom prompt
python test_remote_ollama.py --prompt "Explain quantum computing"
# Test with a different Ollama URL
python test_remote_ollama.py --ollama-url http://your-server-ip:11434
# Test with a different timeout
python test_remote_ollama.py --timeout 600
```
### 5. Stop SSH Tunnels
When you're done testing, stop the SSH tunnels:
```bash
chmod +x stop_ssh_tunnels.sh
./stop_ssh_tunnels.sh
```
## Troubleshooting
### Connection Issues
If you can't connect to the remote server:
1. Check if the server is reachable:
```bash
ping 104.225.217.215
```
2. Verify that Ollama is running on the server:
```bash
ssh root@104.225.217.215 "curl http://localhost:11434/api/tags"
```
3. Check if there are firewall rules blocking the connection:
```bash
ssh root@104.225.217.215 "iptables -L"
```
### SSH Tunnel Issues
If the SSH tunnels aren't working:
1. Make sure you have SSH access to the server:
```bash
ssh root@104.225.217.215
```
2. Check if the ports are already in use:
```bash
netstat -tuln | grep 11434
netstat -tuln | grep 8080
```
3. Try creating the tunnels manually:
```bash
ssh -N -L 11434:localhost:11434 root@104.225.217.215
```
## Advanced Usage
### Testing with OpenWebUI's RAG Capabilities
To test document-based question answering using OpenWebUI's knowledge database:
```bash
python test_remote_ollama.py --prompt "What information do you have about our project?" --model llama3.1
```
### Integrating with Your Local Development
You can use these scripts as a foundation for local development that connects to the remote resources. This allows you to develop and test locally while using the remote server's models and data.
OPENWEBUI_SETUP.md
+6 -6
View File
@@ -9,7 +9,7 @@ OpenWebUI is designed to work with Ollama directly, but it can be configured to
## Prerequisites
1. OpenWebUI installed and running (at http://104.225.217.215:8080)
2. Your AI service deployed and running (at http://your-server-ip:5251)
2. Your AI service deployed and running (at http://your-server-ip:5252)
## Configuration Steps
@@ -23,8 +23,8 @@ services:
openwebui:
image: openwebui/openwebui:latest
environment:
- OLLAMA_API_BASE_URL=http://your-server-ip:5251/ollama
- OPENAI_API_BASE_URL=http://your-server-ip:5251/api
- OLLAMA_API_BASE_URL=http://your-server-ip:5252/ollama
- OPENAI_API_BASE_URL=http://your-server-ip:5252/api
ports:
- "8080:8080"
```
@@ -36,8 +36,8 @@ If you're running OpenWebUI directly, you can modify the .env file in the OpenWe
Add or modify the following environment variables:
```
OLLAMA_API_BASE_URL=http://your-server-ip:5251/ollama
OPENAI_API_BASE_URL=http://your-server-ip:5251/api
OLLAMA_API_BASE_URL=http://your-server-ip:5252/ollama
OPENAI_API_BASE_URL=http://your-server-ip:5252/api
```
Replace `your-server-ip` with the IP address or hostname of the server where your AI service is running.
@@ -90,7 +90,7 @@ If you encounter issues with the integration:
3. Verify that your AI service is running and accessible:
```bash
curl http://your-server-ip:5251/health
curl http://your-server-ip:5252/health
```
4. Verify that the OpenWebUI environment variables are set correctly:
ai_service/.env.example
+2 -2
View File
@@ -1,7 +1,7 @@
# API configuration
API_HOST=0.0.0.0
API_PORT=5251
PUBLIC_URL=http://your-public-url:5251 # Public URL for webhooks, needed for OpenWebUI to send channel messages
API_PORT=5252
PUBLIC_URL=http://your-public-url:5252 # Public URL for webhooks, needed for OpenWebUI to send channel messages
# OpenWebUI configuration
OPENWEBUI_URL=http://104.225.217.215:8080
ai_service/api.py
+33 -1
View File
@@ -623,15 +623,47 @@ async def channel_message_webhook(request: ChannelMessageWebhook):
print("=" * 50)
# Find the chat associated with this OpenWebUI channel
print(f"Looking for chat with OpenWebUI channel ID: {request.channel_id}")
print(f"Number of chats in system: {len(chat_service.chats)}")
# Debug: Print all chats and their channel IDs
print("All chats in the system:")
for cid, chat in chat_service.chats.items():
is_team = chat.get('is_team_chat', False)
channel_id = chat.get('openwebui_channel_id', 'None')
print(f" Chat ID: {cid}, Is Team Chat: {is_team}, OpenWebUI Channel ID: {channel_id}")
chat_id = None
for cid, chat in chat_service.chats.items():
if chat.get('is_team_chat') and chat.get('openwebui_channel_id') == request.channel_id:
chat_id = cid
print(f"Found matching chat: {cid}")
break
if not chat_id:
print(f"No chat found for OpenWebUI channel {request.channel_id}")
return {"status": "error", "message": "No chat found for this channel"}
# If no chat exists for this channel, create one
print("Creating a new team chat for this channel...")
try:
new_chat_id = chat_service.create_chat(
user_id=request.user_id,
title=f"Channel Chat {request.channel_id}",
model_id=config.DEFAULT_MODEL,
is_team_chat=True
)
# Manually set the OpenWebUI channel ID for this chat
chat_service.chats[new_chat_id]['openwebui_channel_id'] = request.channel_id
chat_service._save_chats()
print(f"Created new chat with ID {new_chat_id} for channel {request.channel_id}")
# Use this new chat
chat_id = new_chat_id
except Exception as e:
print(f"Error creating new chat for channel: {str(e)}")
return {"status": "error", "message": "No chat found for this channel and failed to create one"}
# Skip messages from the AI assistant to avoid loops
if request.user_id == "ai-assistant":
ai_service/models/chat_service.py
+10
View File
@@ -69,6 +69,11 @@ class ChatService:
openwebui_channel_id = None
if is_team_chat:
try:
print("=" * 50)
print(f"Creating team chat with title: {chat_title}")
print(f"OpenWebUI URL: {openwebui_channels.openwebui_url}")
print(f"OpenWebUI API Key: {openwebui_channels.openwebui_api_key[:5]}..." if openwebui_channels.openwebui_api_key else "No API key")
# Create a channel in OpenWebUI
channel_response = openwebui_channels.create_channel(
name=chat_title,
@@ -76,13 +81,18 @@ class ChatService:
is_private=True # Team chats are private by default
)
print(f"Channel response: {json.dumps(channel_response, indent=2) if channel_response else 'None'}")
if channel_response:
openwebui_channel_id = channel_response.get('id')
print(f"Created OpenWebUI channel with ID: {openwebui_channel_id}")
else:
print("Failed to create OpenWebUI channel, continuing with local team chat only")
print("=" * 50)
except Exception as e:
print("=" * 50)
print(f"Error creating OpenWebUI channel: {str(e)}")
print("=" * 50)
# Create chat data
self.chats[chat_id] = {
create_ssh_tunnel.sh
Executable
+76
View File
@@ -0,0 +1,76 @@
#!/bin/bash
# Script to create an SSH tunnel to the remote server
# Load environment variables from local_test.env
if [ -f "local_test.env" ]; then
source local_test.env
else
echo "Error: local_test.env file not found. Please run setup_local_test_env.sh first."
exit 1
fi
# Check if required variables are set
if [ -z "$SERVER_IP" ] || [ -z "$SERVER_PORT" ] || [ -z "$SERVER_USER" ]; then
echo "Error: SERVER_IP, SERVER_PORT, or SERVER_USER not set in local_test.env."
exit 1
fi
# Check if password is set
if [ -z "$SERVER_PASSWORD" ]; then
echo "Warning: SERVER_PASSWORD not set in local_test.env. You will be prompted for the password."
fi
# Function to create SSH tunnel
create_tunnel() {
local local_port=$1
local remote_port=$2
echo "Creating SSH tunnel from localhost:$local_port to $SERVER_IP:$remote_port..."
# Check if the tunnel is already established
if netstat -tuln | grep -q ":$local_port "; then
echo "Port $local_port is already in use. Tunnel may already be established."
return 0
fi
# Create the SSH tunnel
if [ -n "$SERVER_PASSWORD" ]; then
# Use sshpass if available
if command -v sshpass &> /dev/null; then
sshpass -p "$SERVER_PASSWORD" ssh -N -L $local_port:localhost:$remote_port -p $SERVER_PORT $SERVER_USER@$SERVER_IP &
else
echo "sshpass not installed. You will be prompted for the password."
ssh -N -L $local_port:localhost:$remote_port -p $SERVER_PORT $SERVER_USER@$SERVER_IP &
fi
else
ssh -N -L $local_port:localhost:$remote_port -p $SERVER_PORT $SERVER_USER@$SERVER_IP &
fi
# Check if the tunnel was established
if [ $? -eq 0 ]; then
echo "SSH tunnel established. Local port $local_port is now forwarded to $SERVER_IP:$remote_port."
echo "Tunnel process ID: $!"
echo $! >> tunnel_pids.txt
else
echo "Failed to establish SSH tunnel."
return 1
fi
}
# Create tunnels for Ollama and OpenWebUI
echo "Setting up SSH tunnels to remote server at $SERVER_IP..."
# Create a file to store tunnel process IDs
touch tunnel_pids.txt
# Create tunnel for Ollama (port 11434)
create_tunnel 11434 11434
# Create tunnel for OpenWebUI (port 8080)
create_tunnel 8080 8080
echo "SSH tunnels established. You can now access:"
echo "- Ollama API at http://localhost:11434"
echo "- OpenWebUI at http://localhost:8080"
echo ""
echo "To stop the tunnels, run: ./stop_ssh_tunnels.sh"
local_test.env
+18
View File
@@ -0,0 +1,18 @@
# Remote server configuration
SERVER_IP=104.225.217.215
SERVER_PORT=22
SERVER_USER=root
SERVER_PASSWORD=S5qqENZNqc
# Ollama configuration
OLLAMA_API_URL=http://104.225.217.215:8080/ollama
# OpenWebUI configuration
OPENWEBUI_URL=http://104.225.217.215:8080
OPENWEBUI_API_KEY=your_openwebui_api_key_here
# Model configuration
DEFAULT_MODEL=llama3.1
# API timeout (in seconds)
API_TIMEOUT=300
local_test.env.example
+18
View File
@@ -0,0 +1,18 @@
# Remote server configuration
SERVER_IP=104.225.217.215
SERVER_PORT=22
SERVER_USER=root
SERVER_PASSWORD=your_password_here
# Ollama configuration
OLLAMA_API_URL=http://104.225.217.215:11434
# OpenWebUI configuration
OPENWEBUI_URL=http://104.225.217.215:8080
OPENWEBUI_API_KEY=your_openwebui_api_key_here
# Model configuration
DEFAULT_MODEL=llama3.1
# API timeout (in seconds)
API_TIMEOUT=300
local_test_config.py
+35
View File
@@ -0,0 +1,35 @@
"""
Configuration for local testing with remote server resources.
"""
import os
from dotenv import load_dotenv
# Try to load environment variables from .env file
dotenv_path = os.path.join(os.path.dirname(__file__), 'local_test.env')
load_dotenv(dotenv_path=dotenv_path)
# Configuration class
class LocalTestConfig:
"""Configuration for local testing with remote server resources."""
# Remote server configuration
SERVER_IP = os.environ.get('SERVER_IP', '104.225.217.215')
SERVER_PORT = os.environ.get('SERVER_PORT', '22')
SERVER_USER = os.environ.get('SERVER_USER', 'root')
# Ollama configuration
OLLAMA_API_URL = os.environ.get('OLLAMA_API_URL', f'http://{SERVER_IP}:11434')
# OpenWebUI configuration
OPENWEBUI_URL = os.environ.get('OPENWEBUI_URL', f'http://{SERVER_IP}:8080')
OPENWEBUI_API_KEY = os.environ.get('OPENWEBUI_API_KEY', '')
# Model configuration
DEFAULT_MODEL = os.environ.get('DEFAULT_MODEL', 'llama3.1')
# API timeout (in seconds)
API_TIMEOUT = int(os.environ.get('API_TIMEOUT', 300)) # 5 minutes
# Create a singleton instance
config = LocalTestConfig()
openwebui_config.md
+3 -3
View File
@@ -15,8 +15,8 @@ You need to modify the OpenWebUI environment variables to point to your AI servi
Add or modify the following environment variables:
```
OLLAMA_API_BASE_URL=http://your-server-ip:5251/ollama
OPENAI_API_BASE_URL=http://your-server-ip:5251/api
OLLAMA_API_BASE_URL=http://your-server-ip:5252/ollama
OPENAI_API_BASE_URL=http://your-server-ip:5252/api
```
Replace `your-server-ip` with the IP address or hostname of the server where your AI service is running.
@@ -69,7 +69,7 @@ If you encounter issues with the integration:
3. Verify that your AI service is running and accessible:
```bash
curl http://your-server-ip:5251/health
curl http://your-server-ip:5252/health
```
4. Verify that the OpenWebUI environment variables are set correctly:
setup_local_test_env.sh
Executable
+53
View File
@@ -0,0 +1,53 @@
#!/bin/bash
# Script to set up the local test environment
# Check if Python is installed
if ! command -v python3 &> /dev/null; then
echo "Python 3 is not installed. Please install Python 3 and try again."
exit 1
fi
# Create a virtual environment if it doesn't exist
if [ ! -d "venv" ]; then
echo "Creating virtual environment..."
python3 -m venv venv
if [ $? -ne 0 ]; then
echo "Failed to create virtual environment. Please check your Python installation."
exit 1
fi
echo "Virtual environment created successfully."
else
echo "Virtual environment already exists."
fi
# Activate the virtual environment
echo "Activating virtual environment..."
source venv/bin/activate
if [ $? -ne 0 ]; then
echo "Failed to activate virtual environment."
exit 1
fi
# Install dependencies
echo "Installing dependencies..."
pip install --upgrade pip
pip install requests python-dotenv argparse
# Create local_test.env file if it doesn't exist
if [ ! -f "local_test.env" ]; then
echo "Creating local_test.env file from template..."
cp local_test.env.example local_test.env
echo "Please edit local_test.env with your server credentials."
else
echo "local_test.env file already exists."
fi
# Make the test script executable
chmod +x test_remote_ollama.py
echo "Setup complete!"
echo "To run the test script:"
echo "1. Activate the virtual environment: source venv/bin/activate"
echo "2. Run the test script: python test_remote_ollama.py"
echo "3. To specify a different model or prompt: python test_remote_ollama.py --model llama3.3 --prompt \"Tell me about AI\""
echo "4. To specify a different Ollama URL: python test_remote_ollama.py --ollama-url http://your-server-ip:11434"
stop_ssh_tunnels.sh
Executable
+29
View File
@@ -0,0 +1,29 @@
#!/bin/bash
# Script to stop SSH tunnels
# Check if the tunnel_pids.txt file exists
if [ ! -f "tunnel_pids.txt" ]; then
echo "No tunnel PIDs file found. No tunnels to stop."
exit 0
fi
# Read the PIDs from the file and kill each process
while read pid; do
if [ -n "$pid" ]; then
echo "Stopping tunnel with PID $pid..."
kill $pid 2>/dev/null || true
fi
done < tunnel_pids.txt
# Remove the PIDs file
rm tunnel_pids.txt
# Check for any remaining SSH tunnels
remaining_tunnels=$(ps aux | grep "ssh -N -L" | grep -v grep | wc -l)
if [ $remaining_tunnels -gt 0 ]; then
echo "Warning: There are still $remaining_tunnels SSH tunnels running."
echo "You may need to kill them manually:"
ps aux | grep "ssh -N -L" | grep -v grep
else
echo "All SSH tunnels have been stopped."
fi
test_ai_service.py
Executable
+214
View File
@@ -0,0 +1,214 @@
"""
Test script for the AI service API.
"""
import requests
import json
import argparse
def test_health(api_url):
"""Test the health endpoint."""
print(f"Testing health endpoint at: {api_url}/health")
try:
response = requests.get(f"{api_url}/health", timeout=30)
response.raise_for_status()
print("Health check successful!")
print(f"Response: {response.json()}")
return True
except Exception as e:
print(f"ERROR: Health check failed: {str(e)}")
return False
def test_config(api_url):
"""Test the config endpoint."""
print(f"Testing config endpoint at: {api_url}/config")
try:
response = requests.get(f"{api_url}/config", timeout=30)
response.raise_for_status()
print("Config check successful!")
print("Configuration:")
config = response.json()
for key, value in config.items():
print(f" {key}: {value}")
return True, config
except Exception as e:
print(f"ERROR: Config check failed: {str(e)}")
return False, None
def test_ollama_connection(api_url):
"""Test the Ollama connection."""
print(f"Testing Ollama connection at: {api_url}/test-ollama")
try:
response = requests.get(f"{api_url}/test-ollama", timeout=60)
response.raise_for_status()
print("Ollama connection test successful!")
result = response.json()
print(f"Status: {result.get('status')}")
print(f"Message: {result.get('message')}")
print(f"Ollama URL: {result.get('ollama_url')}")
if 'models' in result:
print("Available models:")
for model in result.get('models', {}).get('models', []):
print(f" - {model.get('name')}")
return True
except Exception as e:
print(f"ERROR: Ollama connection test failed: {str(e)}")
return False
def test_chat_completion(api_url, model_id, prompt):
"""Test the chat completion endpoint."""
print(f"Testing chat completion at: {api_url}/test-ollama-direct")
print(f"Model: {model_id}")
print(f"Prompt: {prompt}")
try:
# First, create a chat
chat_response = requests.post(
f"{api_url}/chats",
headers={"Content-Type": "application/json"},
json={
"user_id": "test_user",
"title": "Test Chat",
"model_id": model_id
},
timeout=60
)
if chat_response.status_code != 200:
print(f"ERROR: Failed to create chat: {chat_response.status_code}")
print(chat_response.text)
# Try direct Ollama test instead
print("Trying direct Ollama test...")
response = requests.post(
f"{api_url}/test-ollama-direct",
headers={"Content-Type": "application/json"},
json={
"model": model_id,
"prompt": prompt
},
timeout=120
)
response.raise_for_status()
result = response.json()
print("\nResponse:")
print(result.get('response', 'No response'))
return True
chat_id = chat_response.json().get("id")
print(f"Chat created with ID: {chat_id}")
# Send a message to the chat
message_response = requests.post(
f"{api_url}/chats/{chat_id}/messages",
headers={"Content-Type": "application/json"},
json={
"message": prompt,
"user_id": "test_user",
"temperature": 0.7,
"max_tokens": 500
},
timeout=120
)
message_response.raise_for_status()
result = message_response.json()
print("\nResponse:")
print(result.get('content', 'No content in response'))
return True
except Exception as e:
print(f"ERROR: Chat completion test failed: {str(e)}")
return False
def test_rag_completion(api_url, prompt):
"""Test the RAG completion endpoint."""
print(f"Testing RAG completion at: {api_url}/ask-rag")
print(f"Prompt: {prompt}")
try:
response = requests.post(
f"{api_url}/ask-rag",
headers={"Content-Type": "application/json"},
json={"query": prompt},
timeout=120
)
response.raise_for_status()
result = response.json()
print("\nResponse:")
print(result.get('response', 'No response'))
return True
except Exception as e:
print(f"ERROR: RAG completion test failed: {str(e)}")
return False
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test the AI service API')
parser.add_argument('--api-url', type=str, default='http://localhost:5252', help='AI service API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--prompt', type=str, default='What is the capital of France?', help='Prompt to use for testing')
parser.add_argument('--rag-prompt', type=str, default='What information do you have in your knowledge base?', help='Prompt to use for RAG testing')
args = parser.parse_args()
print("=== AI Service API Test ===")
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print()
# Test health endpoint
print("=== Testing Health Endpoint ===")
health_success = test_health(args.api_url)
print()
# Test config endpoint
print("=== Testing Config Endpoint ===")
config_success, config = test_config(args.api_url)
print()
# Test Ollama connection
print("=== Testing Ollama Connection ===")
ollama_success = test_ollama_connection(args.api_url)
print()
# Test chat completion
if ollama_success:
print("=== Testing Chat Completion ===")
chat_success = test_chat_completion(args.api_url, args.model, args.prompt)
print()
# Test RAG completion
print("=== Testing RAG Completion ===")
rag_success = test_rag_completion(args.api_url, args.rag_prompt)
print()
else:
chat_success = False
rag_success = False
# Print summary
print("=== Test Summary ===")
print(f"Health Endpoint: {'SUCCESS' if health_success else 'FAILED'}")
print(f"Config Endpoint: {'SUCCESS' if config_success else 'FAILED'}")
print(f"Ollama Connection: {'SUCCESS' if ollama_success else 'FAILED'}")
print(f"Chat Completion: {'SUCCESS' if chat_success else 'FAILED'}")
print(f"RAG Completion: {'SUCCESS' if rag_success else 'FAILED'}")
if __name__ == "__main__":
main()
test_direct_ollama.py
Executable
+76
View File
@@ -0,0 +1,76 @@
"""
Test script for the direct Ollama endpoint.
"""
import requests
import json
import argparse
import time
def test_direct_ollama(api_url, model_id, prompt):
"""Test the direct Ollama endpoint."""
print(f"Testing direct Ollama endpoint at: {api_url}/test-ollama-direct")
print(f"Model: {model_id}")
print(f"Prompt: {prompt}")
try:
start_time = time.time()
response = requests.post(
f"{api_url}/test-ollama-direct",
headers={"Content-Type": "application/json"},
json={
"model": model_id,
"prompt": prompt
},
timeout=300 # 5 minutes timeout
)
end_time = time.time()
elapsed_time = end_time - start_time
response.raise_for_status()
result = response.json()
print(f"\nResponse (took {elapsed_time:.2f} seconds):")
# Handle different response formats
content = None
if 'response' in result and isinstance(result['response'], dict) and 'message' in result['response']:
content = result['response']['message'].get('content')
elif 'response' in result and isinstance(result['response'], str):
content = result['response']
else:
content = str(result)
print(content or 'No content in response')
return True
except Exception as e:
print(f"ERROR: Direct Ollama test failed: {str(e)}")
return False
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test the direct Ollama endpoint')
parser.add_argument('--api-url', type=str, default='http://localhost:5252', help='AI service API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--prompt', type=str, default='What is the capital of France?', help='Prompt to use for testing')
args = parser.parse_args()
print("=== Direct Ollama Test ===")
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print(f"Prompt: {args.prompt}")
print()
# Test direct Ollama endpoint
success = test_direct_ollama(args.api_url, args.model, args.prompt)
# Print summary
print("\n=== Test Summary ===")
print(f"Direct Ollama Test: {'SUCCESS' if success else 'FAILED'}")
if __name__ == "__main__":
main()
test_ollama_custom.py
Executable
+104
View File
@@ -0,0 +1,104 @@
"""
Test script for the Ollama API with custom prompts.
"""
import requests
import json
import argparse
import time
class OllamaRequest:
"""Request model for Ollama API."""
def __init__(self, model, prompt, system_prompt=None):
self.model = model
self.prompt = prompt
self.system_prompt = system_prompt or "You are a helpful assistant."
def to_json(self):
"""Convert to JSON for the API request."""
messages = []
# Add system message
messages.append({"role": "system", "content": self.system_prompt})
# Add user message
messages.append({"role": "user", "content": self.prompt})
return {
"model": self.model,
"messages": messages,
"stream": False
}
def test_ollama_api(api_url, model, prompt, system_prompt=None):
"""Test the Ollama API directly."""
print(f"Testing Ollama API at: {api_url}")
print(f"Model: {model}")
print(f"Prompt: {prompt}")
if system_prompt:
print(f"System prompt: {system_prompt}")
# Create the request
request = OllamaRequest(model, prompt, system_prompt)
request_json = request.to_json()
try:
start_time = time.time()
# Make the API call
response = requests.post(
api_url,
headers={"Content-Type": "application/json"},
json=request_json,
timeout=300 # 5 minutes timeout
)
end_time = time.time()
elapsed_time = end_time - start_time
response.raise_for_status()
# Parse the response
result = response.json()
print(f"\nResponse (took {elapsed_time:.2f} seconds):")
print(json.dumps(result, indent=2))
# Extract the content
if 'message' in result:
content = result['message'].get('content', 'No content in response')
print("\nContent:")
print(content)
return True
except Exception as e:
print(f"ERROR: Ollama API test failed: {str(e)}")
return False
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test the Ollama API with custom prompts')
parser.add_argument('--api-url', type=str, default='http://localhost:11434/api/chat', help='Ollama API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--prompt', type=str, default='What is the capital of France?', help='Prompt to use for testing')
parser.add_argument('--system-prompt', type=str, default=None, help='System prompt to use for testing')
args = parser.parse_args()
print("=== Ollama API Test ===")
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print(f"Prompt: {args.prompt}")
if args.system_prompt:
print(f"System prompt: {args.system_prompt}")
print()
# Test Ollama API
success = test_ollama_api(args.api_url, args.model, args.prompt, args.system_prompt)
# Print summary
print("\n=== Test Summary ===")
print(f"Ollama API Test: {'SUCCESS' if success else 'FAILED'}")
if __name__ == "__main__":
main()
test_rag.py
+1 -1
View File
@@ -15,7 +15,7 @@ from pprint import pprint
# Default configuration
DEFAULT_API_URL = "http://localhost:5252" # Local development server
DEFAULT_REMOTE_API_URL = "http://157.157.221.29:5251" # Remote server
DEFAULT_REMOTE_API_URL = "http://157.157.221.29:5252" # Remote server
DEFAULT_MODEL = "llama3.1"
class RAGTester:
test_remote_ollama.py
Executable
+165
View File
@@ -0,0 +1,165 @@
"""
Test script for connecting to a remote Ollama server.
"""
import os
import sys
import requests
import json
import argparse
# Import local test configuration
from local_test_config import config
def test_ollama_connection():
"""Test the connection to the Ollama API."""
print(f"Testing connection to Ollama API at: {config.OLLAMA_API_URL}")
try:
# Try to connect to Ollama API via OpenWebUI
# OpenWebUI exposes Ollama models through its own API
response = requests.get(f"{config.OPENWEBUI_URL}/api/models", timeout=config.API_TIMEOUT)
response.raise_for_status()
# Print the models from OpenWebUI
print("Connection successful!")
print("Available models:")
models_data = response.json()
if isinstance(models_data, list):
for model in models_data:
print(f"- {model.get('id')}")
else:
print(f"Unexpected response format: {models_data}")
return True
except requests.exceptions.Timeout as e:
print(f"ERROR: Timeout connecting to Ollama API: {str(e)}. The request exceeded the {config.API_TIMEOUT} second timeout.")
return False
except requests.exceptions.ConnectionError as e:
print(f"ERROR: Connection error to Ollama API: {str(e)}. Please check if Ollama is running at {config.OLLAMA_API_URL}.")
return False
except Exception as e:
print(f"ERROR: Error connecting to Ollama API: {str(e)}")
return False
def test_generate_response(model_id=None, prompt=None):
"""Test generating a response from the model."""
if model_id is None:
model_id = config.DEFAULT_MODEL
if prompt is None:
prompt = "What is the capital of France?"
print(f"Testing model: {model_id}")
print(f"Prompt: {prompt}")
try:
# Prepare the request for OpenWebUI's chat completions API
request_json = {
"model": model_id,
"messages": [
{"role": "user", "content": prompt}
],
"stream": False,
"temperature": 0.7,
"max_tokens": 500
}
# Make the API call to OpenWebUI's chat completions API
print(f"Sending request to OpenWebUI API at: {config.OPENWEBUI_URL}/api/chat/completions")
response = requests.post(
f"{config.OPENWEBUI_URL}/api/chat/completions",
headers={"Content-Type": "application/json"},
json=request_json,
timeout=config.API_TIMEOUT
)
response.raise_for_status()
# Parse the response
response_data = response.json()
# Print the response (OpenWebUI uses OpenAI-compatible format)
print("\nResponse:")
content = response_data.get('choices', [{}])[0].get('message', {}).get('content', 'No content in response')
print(content)
return True
except requests.exceptions.Timeout as e:
print(f"ERROR: Timeout generating response: {str(e)}. The request exceeded the {config.API_TIMEOUT} second timeout.")
return False
except requests.exceptions.ConnectionError as e:
print(f"ERROR: Connection error to Ollama API: {str(e)}. Please check if Ollama is running at {config.OLLAMA_API_URL}.")
return False
except Exception as e:
print(f"ERROR: Error generating response: {str(e)}")
return False
def test_openwebui_connection():
"""Test the connection to OpenWebUI."""
print(f"Testing connection to OpenWebUI at: {config.OPENWEBUI_URL}")
try:
# Try to connect to OpenWebUI
response = requests.get(f"{config.OPENWEBUI_URL}/api/health", timeout=config.API_TIMEOUT)
response.raise_for_status()
# Print the response
print("Connection successful!")
print(f"OpenWebUI status: {response.text}")
return True
except requests.exceptions.Timeout as e:
print(f"ERROR: Timeout connecting to OpenWebUI: {str(e)}. The request exceeded the {config.API_TIMEOUT} second timeout.")
return False
except requests.exceptions.ConnectionError as e:
print(f"ERROR: Connection error to OpenWebUI: {str(e)}. Please check if OpenWebUI is running at {config.OPENWEBUI_URL}.")
return False
except Exception as e:
print(f"ERROR: Error connecting to OpenWebUI: {str(e)}")
return False
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test remote Ollama and OpenWebUI connections')
parser.add_argument('--model', type=str, default=config.DEFAULT_MODEL, help='Model to use for testing')
parser.add_argument('--prompt', type=str, default="What is the capital of France?", help='Prompt to use for testing')
parser.add_argument('--ollama-url', type=str, default=config.OLLAMA_API_URL, help='Ollama API URL')
parser.add_argument('--openwebui-url', type=str, default=config.OPENWEBUI_URL, help='OpenWebUI URL')
parser.add_argument('--timeout', type=int, default=config.API_TIMEOUT, help='API timeout in seconds')
args = parser.parse_args()
# Update configuration with command-line arguments
config.OLLAMA_API_URL = args.ollama_url
config.OPENWEBUI_URL = args.openwebui_url
config.API_TIMEOUT = args.timeout
print("=== Remote Connection Test ===")
print(f"Ollama API URL: {config.OLLAMA_API_URL}")
print(f"OpenWebUI URL: {config.OPENWEBUI_URL}")
print(f"API Timeout: {config.API_TIMEOUT} seconds")
print()
# Test Ollama connection
print("=== Testing Ollama Connection ===")
ollama_success = test_ollama_connection()
print()
# Test OpenWebUI connection
print("=== Testing OpenWebUI Connection ===")
openwebui_success = test_openwebui_connection()
print()
# Test generating a response
if ollama_success:
print("=== Testing Model Response ===")
test_generate_response(args.model, args.prompt)
print("\n=== Test Summary ===")
print(f"Ollama Connection: {'SUCCESS' if ollama_success else 'FAILED'}")
print(f"OpenWebUI Connection: {'SUCCESS' if openwebui_success else 'FAILED'}")
if __name__ == "__main__":
main()
test_simple_team_chat.py
Executable
+91
View File
@@ -0,0 +1,91 @@
#!/usr/bin/env python3
"""
Simple test script for team chat functionality.
"""
import requests
import argparse
import sys
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Simple test for team chat functionality')
parser.add_argument('--api-url', type=str, default='http://localhost:5252', help='AI service API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--user-id', type=str, default='test_user', help='User ID for testing')
parser.add_argument('--chat-id', type=str, help='Existing chat ID to use (optional)')
parser.add_argument('--message', type=str, default='Hello team!', help='Message to send')
parser.add_argument('--with-mention', action='store_true', help='Add @ai mention to message')
args = parser.parse_args()
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print(f"User ID: {args.user_id}")
# Create a chat if no chat ID is provided
chat_id = args.chat_id
if not chat_id:
print("\nCreating a new team chat...")
try:
response = requests.post(
f"{args.api_url}/chats",
headers={"Content-Type": "application/json"},
json={
"user_id": args.user_id,
"title": "Simple Team Chat Test",
"model_id": args.model,
"is_team_chat": True
},
timeout=30
)
response.raise_for_status()
chat = response.json()
chat_id = chat.get("id")
print(f"Created team chat with ID: {chat_id}")
print(f"OpenWebUI Channel ID: {chat.get('openwebui_channel_id', 'Not available')}")
print(f"Team Members: {chat.get('team_members', [])}")
except Exception as e:
print(f"Error creating team chat: {str(e)}")
sys.exit(1)
else:
print(f"\nUsing existing chat ID: {chat_id}")
# Prepare message
message = args.message
if args.with_mention:
message = f"@ai {message}"
print(f"\nSending message WITH @ai mention: {message}")
else:
print(f"\nSending message WITHOUT @ai mention: {message}")
# Send message
try:
response = requests.post(
f"{args.api_url}/chats/{chat_id}/messages",
headers={"Content-Type": "application/json"},
json={
"message": message,
"user_id": args.user_id
},
timeout=10
)
response.raise_for_status()
result = response.json()
print("\nMessage sent successfully!")
print(f"AI Response: {result.get('content', 'No content in response')}")
print("\nNote: When using the API directly, the AI will always respond")
print("The @ai mention functionality only applies to messages sent through OpenWebUI channels")
print(f"\nYou can check the OpenWebUI interface at: http://104.225.217.215:8080/")
print(f"Chat ID: {chat_id}")
except Exception as e:
print(f"Error sending message: {str(e)}")
sys.exit(1)
if __name__ == "__main__":
main()
test_team_chat_mentions.py
Executable
+266
View File
@@ -0,0 +1,266 @@
#!/usr/bin/env python3
"""
Test script for team chat mentions functionality.
This script tests the AI response to @ai mentions in team chats.
"""
import requests
import json
import argparse
import time
import sys
from typing import Dict, Any, List, Tuple, Optional
def test_health(api_url: str) -> bool:
"""Test the health endpoint."""
print(f"Testing health endpoint at: {api_url}/health")
try:
response = requests.get(f"{api_url}/health", timeout=30)
response.raise_for_status()
print("✅ Health check successful!")
print(f"Response: {response.json()}")
return True
except Exception as e:
print(f"❌ ERROR: Health check failed: {str(e)}")
return False
def test_create_team_chat(api_url: str, user_id: str, title: str, model_id: str) -> Tuple[bool, Optional[str]]:
"""
Test creating a team chat.
Args:
api_url: API URL
user_id: User ID
title: Chat title
model_id: Model ID
Returns:
Tuple of (success, chat_id)
"""
print(f"Creating team chat with title: {title}")
try:
response = requests.post(
f"{api_url}/chats",
headers={"Content-Type": "application/json"},
json={
"user_id": user_id,
"title": title,
"model_id": model_id,
"is_team_chat": True
},
timeout=60
)
response.raise_for_status()
chat = response.json()
chat_id = chat.get("id")
print(f"✅ Team chat created successfully with ID: {chat_id}")
print(f"OpenWebUI Channel ID: {chat.get('openwebui_channel_id', 'Not available')}")
print(f"Team Members: {chat.get('team_members', [])}")
return True, chat_id
except Exception as e:
print(f"❌ ERROR: Failed to create team chat: {str(e)}")
return False, None
def test_add_team_member(api_url: str, chat_id: str, user_id: str) -> bool:
"""
Test adding a member to a team chat.
Args:
api_url: API URL
chat_id: Chat ID
user_id: User ID to add
Returns:
Success status
"""
print(f"Adding user {user_id} to team chat {chat_id}")
try:
response = requests.post(
f"{api_url}/chats/{chat_id}/members/{user_id}",
timeout=30
)
response.raise_for_status()
print(f"✅ User {user_id} added to team chat successfully")
return True
except Exception as e:
print(f"❌ ERROR: Failed to add user to team chat: {str(e)}")
return False
def test_send_team_message_with_mention(api_url: str, chat_id: str, user_id: str, message: str, mention: str) -> bool:
"""
Test sending a message with an @ai mention to a team chat.
Args:
api_url: API URL
chat_id: Chat ID
user_id: User ID
message: Message content
mention: Mention to use (@ai, @bot, etc.)
Returns:
Success status
"""
full_message = f"{mention} {message}"
print(f"Sending message to team chat {chat_id}: {full_message}")
try:
response = requests.post(
f"{api_url}/chats/{chat_id}/messages",
headers={"Content-Type": "application/json"},
json={
"message": full_message,
"user_id": user_id,
"temperature": 0.7,
"max_tokens": 500
},
timeout=60
)
response.raise_for_status()
result = response.json()
print(f"✅ Message with mention sent successfully")
print(f"AI Response: {result.get('content', 'No content in response')[:100]}...")
return True
except Exception as e:
print(f"❌ ERROR: Failed to send message to team chat: {str(e)}")
return False
def test_send_team_message_without_mention(api_url: str, chat_id: str, user_id: str, message: str) -> bool:
"""
Test sending a message without an @ai mention to a team chat.
Args:
api_url: API URL
chat_id: Chat ID
user_id: User ID
message: Message content
Returns:
Success status
"""
print(f"Sending message without mention to team chat {chat_id}: {message}")
try:
response = requests.post(
f"{api_url}/chats/{chat_id}/messages",
headers={"Content-Type": "application/json"},
json={
"message": message,
"user_id": user_id,
"temperature": 0.7,
"max_tokens": 500
},
timeout=60
)
response.raise_for_status()
result = response.json()
print(f"✅ Message without mention sent successfully")
# Note: When using the API directly, the AI will always respond
# The AI_RESPOND_TO_ALL setting only applies to messages received through the webhook
print(f"Note: AI responded because we're using the API directly: {result.get('content', 'No content in response')[:100]}...")
print("The @ai mention functionality only applies to messages sent through OpenWebUI channels")
return True
except Exception as e:
print(f"❌ ERROR: Failed to send message to team chat: {str(e)}")
return False
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test team chat mentions functionality')
parser.add_argument('--api-url', type=str, default='http://localhost:5252', help='AI service API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--user-id', type=str, default='test_user', help='User ID for testing')
parser.add_argument('--second-user-id', type=str, default='test_user2', help='Second user ID for testing team membership')
parser.add_argument('--mention', type=str, default='@ai', help='Mention to use (@ai, @bot, etc.)')
parser.add_argument('--message', type=str, default='Can you help me with a project?', help='Message to send to the team chat')
args = parser.parse_args()
print("=== Team Chat Mentions Functionality Test ===")
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print(f"User ID: {args.user_id}")
print(f"Mention: {args.mention}")
print()
# Test health endpoint
print("=== Testing Health Endpoint ===")
health_success = test_health(args.api_url)
print()
if not health_success:
print("❌ Health check failed. Aborting tests.")
sys.exit(1)
# Test creating a team chat
print("=== Creating Team Chat ===")
chat_success, chat_id = test_create_team_chat(
args.api_url,
args.user_id,
f"Mention Test Chat {time.strftime('%Y-%m-%d %H:%M:%S')}",
args.model
)
print()
if not chat_success or not chat_id:
print("❌ Failed to create team chat. Aborting tests.")
sys.exit(1)
# Test adding a team member
print("=== Adding Team Member ===")
member_success = test_add_team_member(args.api_url, chat_id, args.second_user_id)
print()
# Test sending a message without a mention
print("=== Sending Message WITHOUT Mention ===")
no_mention_success = test_send_team_message_without_mention(
args.api_url,
chat_id,
args.user_id,
f"This is a message without a mention: {args.message}"
)
print()
# Test sending a message with a mention
print("=== Sending Message WITH Mention ===")
mention_success = test_send_team_message_with_mention(
args.api_url,
chat_id,
args.user_id,
args.message,
args.mention
)
print()
# Print summary
print("=== Test Summary ===")
print(f"Health Endpoint: {'✅ SUCCESS' if health_success else '❌ FAILED'}")
print(f"Create Team Chat: {'✅ SUCCESS' if chat_success else '❌ FAILED'}")
print(f"Add Team Member: {'✅ SUCCESS' if member_success else '❌ FAILED'}")
print(f"Send Message WITHOUT Mention: {'✅ SUCCESS' if no_mention_success else '❌ FAILED'}")
print(f"Send Message WITH Mention: {'✅ SUCCESS' if mention_success else '❌ FAILED'}")
if chat_success and chat_id:
print(f"\nCreated team chat ID: {chat_id}")
print("You can now check the OpenWebUI interface to see if the channel was created")
print("and if the AI responded to the message with the mention.")
print(f"OpenWebUI URL: http://104.225.217.215:8080/")
if __name__ == "__main__":
main()
test_team_chats.py
Executable
+243
View File
@@ -0,0 +1,243 @@
#!/usr/bin/env python3
"""
Test script for team chats functionality.
This script tests the team chat features of the AI service, including:
- Creating team chats
- Adding members to team chats
- Sending messages to team chats
- Verifying integration with OpenWebUI channels
"""
import requests
import json
import argparse
import time
import sys
from typing import Dict, Any, List, Tuple, Optional
def test_health(api_url: str) -> bool:
"""Test the health endpoint."""
print(f"Testing health endpoint at: {api_url}/health")
try:
response = requests.get(f"{api_url}/health", timeout=30)
response.raise_for_status()
print("✅ Health check successful!")
print(f"Response: {response.json()}")
return True
except Exception as e:
print(f"❌ ERROR: Health check failed: {str(e)}")
return False
def test_create_team_chat(api_url: str, user_id: str, title: str, model_id: str) -> Tuple[bool, Optional[str]]:
"""
Test creating a team chat.
Args:
api_url: API URL
user_id: User ID
title: Chat title
model_id: Model ID
Returns:
Tuple of (success, chat_id)
"""
print(f"Creating team chat with title: {title}")
try:
response = requests.post(
f"{api_url}/chats",
headers={"Content-Type": "application/json"},
json={
"user_id": user_id,
"title": title,
"model_id": model_id,
"is_team_chat": True
},
timeout=60
)
response.raise_for_status()
chat = response.json()
chat_id = chat.get("id")
print(f"✅ Team chat created successfully with ID: {chat_id}")
print(f"OpenWebUI Channel ID: {chat.get('openwebui_channel_id', 'Not available')}")
print(f"Team Members: {chat.get('team_members', [])}")
return True, chat_id
except Exception as e:
print(f"❌ ERROR: Failed to create team chat: {str(e)}")
return False, None
def test_add_team_member(api_url: str, chat_id: str, user_id: str) -> bool:
"""
Test adding a member to a team chat.
Args:
api_url: API URL
chat_id: Chat ID
user_id: User ID to add
Returns:
Success status
"""
print(f"Adding user {user_id} to team chat {chat_id}")
try:
response = requests.post(
f"{api_url}/chats/{chat_id}/members/{user_id}",
timeout=30
)
response.raise_for_status()
print(f"✅ User {user_id} added to team chat successfully")
return True
except Exception as e:
print(f"❌ ERROR: Failed to add user to team chat: {str(e)}")
return False
def test_send_team_message(api_url: str, chat_id: str, user_id: str, message: str) -> bool:
"""
Test sending a message to a team chat.
Args:
api_url: API URL
chat_id: Chat ID
user_id: User ID
message: Message content
Returns:
Success status
"""
print(f"Sending message to team chat {chat_id}: {message}")
try:
response = requests.post(
f"{api_url}/chats/{chat_id}/messages",
headers={"Content-Type": "application/json"},
json={
"message": message,
"user_id": user_id,
"temperature": 0.7,
"max_tokens": 500
},
timeout=120
)
response.raise_for_status()
result = response.json()
print(f"✅ Message sent successfully")
print(f"AI Response: {result.get('content', 'No content in response')[:100]}...")
return True
except Exception as e:
print(f"❌ ERROR: Failed to send message to team chat: {str(e)}")
return False
def test_get_user_chats(api_url: str, user_id: str) -> Tuple[bool, List[Dict[str, Any]]]:
"""
Test getting all chats for a user.
Args:
api_url: API URL
user_id: User ID
Returns:
Tuple of (success, chats)
"""
print(f"Getting chats for user {user_id}")
try:
response = requests.get(
f"{api_url}/chats/user/{user_id}",
timeout=30
)
response.raise_for_status()
chats = response.json()
team_chats = [chat for chat in chats if chat.get("is_team_chat", False)]
print(f"✅ Found {len(chats)} chats for user {user_id}, {len(team_chats)} are team chats")
return True, chats
except Exception as e:
print(f"❌ ERROR: Failed to get user chats: {str(e)}")
return False, []
def main():
"""Main function."""
parser = argparse.ArgumentParser(description='Test team chats functionality')
parser.add_argument('--api-url', type=str, default='http://localhost:5252', help='AI service API URL')
parser.add_argument('--model', type=str, default='llama3.1', help='Model to use for testing')
parser.add_argument('--user-id', type=str, default='test_user', help='User ID for testing')
parser.add_argument('--second-user-id', type=str, default='test_user2', help='Second user ID for testing team membership')
parser.add_argument('--message', type=str, default='Hello team! Can you help me with a project?', help='Message to send to the team chat')
args = parser.parse_args()
print("=== Team Chats Functionality Test ===")
print(f"API URL: {args.api_url}")
print(f"Model: {args.model}")
print(f"User ID: {args.user_id}")
print()
# Test health endpoint
print("=== Testing Health Endpoint ===")
health_success = test_health(args.api_url)
print()
if not health_success:
print("❌ Health check failed. Aborting tests.")
sys.exit(1)
# Test creating a team chat
print("=== Creating Team Chat ===")
chat_success, chat_id = test_create_team_chat(
args.api_url,
args.user_id,
f"Team Chat Test {time.strftime('%Y-%m-%d %H:%M:%S')}",
args.model
)
print()
if not chat_success or not chat_id:
print("❌ Failed to create team chat. Aborting tests.")
sys.exit(1)
# Test adding a team member
print("=== Adding Team Member ===")
member_success = test_add_team_member(args.api_url, chat_id, args.second_user_id)
print()
# Test sending a message to the team chat
print("=== Sending Message to Team Chat ===")
message_success = test_send_team_message(args.api_url, chat_id, args.user_id, args.message)
print()
# Test getting user chats
print("=== Getting User Chats ===")
chats_success, chats = test_get_user_chats(args.api_url, args.user_id)
print()
# Print summary
print("=== Test Summary ===")
print(f"Health Endpoint: {'✅ SUCCESS' if health_success else '❌ FAILED'}")
print(f"Create Team Chat: {'✅ SUCCESS' if chat_success else '❌ FAILED'}")
print(f"Add Team Member: {'✅ SUCCESS' if member_success else '❌ FAILED'}")
print(f"Send Team Message: {'✅ SUCCESS' if message_success else '❌ FAILED'}")
print(f"Get User Chats: {'✅ SUCCESS' if chats_success else '❌ FAILED'}")
if chat_success and chat_id:
print(f"\nCreated team chat ID: {chat_id}")
print("You can now check the OpenWebUI interface to see if the channel was created")
print("and if the message was sent to the channel.")
print(f"OpenWebUI URL: http://104.225.217.215:8080/")
if __name__ == "__main__":
main()
tunnel_pids.txt
+2
View File
@@ -0,0 +1,2 @@
97911
97914