Building a Decentralized AI Chatbot

Traditional AI Bot:
User -> Your Server -> OpenAI API -> Response
     (hosting $)   (API $$$$)    (privacy loss)

Ixian AI Bot:
User <--> QuIXI <--> Your Bot <--> Local AI (LLM Studio/Ollama)
        ($0)   (one-time hardware)   (full control)

# Download from https://lmstudio.ai
# Or use Ollama as alternative: https://ollama.ai

# For this guide, we'll use LM Studio
# Install and launch LM Studio

# Clone repositories
cd ~
git clone https://github.com/ixian-platform/Ixian-Core.git
git clone https://github.com/ixian-platform/QuIXI.git

# Build QuIXI
cd QuIXI
dotnet build -c Release
cd QuIXI/bin/Release/net8.0

# Network settings (mainnet)
addPeer = seed1.ixian.io:10234
# For testnet, use: addPeer = seedtest1.ixian.io:11234

# API settings
apiPort = 8001
apiBind = 127.0.0.1
addApiUser = admin:changeme123

# MQTT integration
mqDriver = mqtt
mqHost = localhost
mqPort = 1883

# Bot identity
name = ai-assistant-001

# Install Python dependencies
pip install requests openai paho-mqtt python-dotenv

# Install MQTT broker
sudo apt install -y mosquitto mosquitto-clients  # Linux
# or
brew install mosquitto  # Mac

#!/usr/bin/env python3
"""
Decentralized AI Chatbot using QuIXI + Local LLM
"""

import os
import json
import time
import requests
from openai import OpenAI
import paho.mqtt.client as mqtt

# Configuration
QUIXI_API = "http://localhost:8001"
LM_STUDIO_API = "http://localhost:1234/v1"  # LM Studio local server
MQTT_BROKER = "localhost"
MQTT_PORT = 1883

# Bot personality
SYSTEM_PROMPT = """You are a helpful AI assistant running on a decentralized network. 
You are privacy-focused and run locally, not on cloud servers. Be friendly, concise, 
and knowledgeable. You can discuss technology, answer questions, and have conversations."""

# Initialize OpenAI client pointing to local LM Studio
client = OpenAI(base_url=LM_STUDIO_API, api_key="not-needed")

# Conversation memory (address -> message history)
conversation_history = {}

def send_message(address, message):
    """Send a message back to a user via QuIXI"""
    try:
        response = requests.get(f"{QUIXI_API}/sendChatMessage", params={
            "address": address,
            "message": message,
            "channel": 0
        })
        return response.status_code == 200
    except Exception as e:
        print(f"Error sending message: {e}")
        return False

def get_ai_response(user_address, user_message):
    """Get response from local LLM with conversation history"""
    
    # Initialize conversation history for new users
    if user_address not in conversation_history:
        conversation_history[user_address] = [
            {"role": "system", "content": SYSTEM_PROMPT}
        ]
    
    # Add user message to history
    conversation_history[user_address].append({
        "role": "user",
        "content": user_message
    })
    
    # Keep only last 10 messages to manage memory
    if len(conversation_history[user_address]) > 21:  # 1 system + 20 messages
        conversation_history[user_address] = [
            conversation_history[user_address][0]  # Keep system prompt
        ] + conversation_history[user_address][-20:]  # Keep last 20
    
    try:
        # Call local LLM
        completion = client.chat.completions.create(
            model="local-model",  # Model name doesn't matter for LM Studio
            messages=conversation_history[user_address],
            temperature=0.7,
            max_tokens=500
        )
        
        ai_response = completion.choices[0].message.content
        
        # Add AI response to history
        conversation_history[user_address].append({
            "role": "assistant",
            "content": ai_response
        })
        
        return ai_response
    
    except Exception as e:
        print(f"Error getting AI response: {e}")
        return "Sorry, I encountered an error processing your request. Please try again."

def handle_command(address, message):
    """Handle special commands"""
    cmd = message.lower().strip()
    
    if cmd == "/reset":
        if address in conversation_history:
            conversation_history[address] = [
                {"role": "system", "content": SYSTEM_PROMPT}
            ]
        return "🔄 Conversation reset. Let's start fresh!"
    
    elif cmd == "/help":
        return """🤖 AI Assistant Commands:
• Chat normally for AI responses
• /reset - Clear conversation history
• /help - Show this message
• /stats - Bot statistics

I'm running locally with full privacy - your messages never leave this device!"""
    
    elif cmd == "/stats":
        msg_count = len(conversation_history.get(address, [])) - 1  # Exclude system prompt
        total_users = len(conversation_history)
        return f"""📊 Bot Statistics:
• Messages in this conversation: {msg_count}
• Total users served: {total_users}
• Model: Llama 3 (local)
• Privacy: 100% (all local processing)"""
    
    return None  # Not a command, process as normal message

def on_connect(mqtt_client, userdata, flags, rc):
    """Callback when connected to MQTT broker"""
    print(f"Connected to MQTT broker with result code {rc}")
    
    # Subscribe to chat messages and contact requests
    mqtt_client.subscribe("Chat/#")
    mqtt_client.subscribe("RequestAdd2/#")
    
    print("🤖 AI Chatbot is ready!")
    print("Add your bot as a contact in Spixi and start chatting!")

def on_message(mqtt_client, userdata, msg):
    """Callback when a message is received"""
    try:
        # Parse incoming message
        data = json.loads(msg.payload.decode())
        
        # Handle contact requests (auto-accept)
        if msg.topic.startswith("RequestAdd2"):
            sender = data.get("sender", {})
            if sender:
                print(f"📥 Auto-accepting contact: {sender}")
                requests.get(f"{QUIXI_API}/acceptContact", params={"address": sender})
                time.sleep(1)  # Wait for contact to be added
                send_message(sender, "👋 Hi! I'm your local AI assistant. Ask me anything!\n\nI run on your hardware with full privacy. Type /help for commands.")
        
        # Handle chat messages
        elif msg.topic.startswith("Chat"):
            sender = data.get("sender", {})
            message = data.get("data", {}).get("data", "").strip()
            
            if not sender or not message:
                return
            
            print(f"💬 Message from {sender[:8]}...: {message}")
            
            # Check for commands first
            command_response = handle_command(sender, message)
            if command_response:
                send_message(sender, command_response)
                return
            
            # Show typing indicator (optional)
            print(f"🤔 Processing with AI...")
            
            # Get AI response
            ai_response = get_ai_response(sender, message)
            
            # Send response
            print(f"🤖 Response: {ai_response[:100]}...")
            send_message(sender, ai_response)
    
    except Exception as e:
        print(f"❌ Error processing message: {e}")

def main():
    """Main bot loop"""
    print("🚀 Starting Decentralized AI Chatbot...")
    print(f"📡 QuIXI API: {QUIXI_API}")
    print(f"🧠 LM Studio: {LM_STUDIO_API}")
    
    # Test LM Studio connection
    try:
        response = requests.get(f"{LM_STUDIO_API}/models")
        print(f"✓ LM Studio connected")
    except:
        print(f"⚠️  Warning: Cannot connect to LM Studio. Make sure it's running!")
        return
    
    # Test QuIXI connection
    try:
        response = requests.get(f"{QUIXI_API}/myWallet")
        if response.status_code == 200:
            wallet_map = response.json().get("result", {})
            if isinstance(wallet_map, dict) and wallet_map:
                print("✓ QuIXI connected")
                addresses = list(wallet_map.keys())
                primary = addresses[0]
                print(f"📍 Primary bot address: {primary}")
                if len(addresses) > 1:
                    print(f"📍 Additional addresses ({len(addresses)-1}):")
                    for addr in addresses[1:]:
                        print(f"   - {addr}")
                print("\n💰 Wallet balances:")
                for addr, balance in wallet_map.items():
                    print(f"   {addr}: {balance} IXI")
                print("\n🎯 Add primary bot address as a contact in Spixi to start chatting!")
            else:
                print("⚠️  Warning: QuIXI returned empty wallet data.")
        else:
            print(f"⚠️  Warning: QuIXI returned status {response.status_code}")
    except Exception as e:
        print(f"⚠️  Warning: Cannot connect to QuIXI. Make sure it's running! ({e})")
        return
    
    # Connect to MQTT broker
    mqtt_client = mqtt.Client()
    mqtt_client.on_connect = on_connect
    mqtt_client.on_message = on_message
    
    try:
        mqtt_client.connect(MQTT_BROKER, MQTT_PORT, 60)
        mqtt_client.loop_forever()
    except KeyboardInterrupt:
        print("\n👋 Shutting down bot...")
        mqtt_client.disconnect()
    except Exception as e:
        print(f"❌ Error: {e}")

if __name__ == "__main__":
    main()

chmod +x ai_chatbot.py

# Open LM Studio GUI
# Load your model
# Start Local Server
# Keep window open

cd ~/QuIXI/QuIXI/bin/Release/net8.0
./QuIXI
# Note the Ixian address shown

mosquitto

python3 ai_chatbot.py

🚀 Starting Decentralized AI Chatbot...
📡 QuIXI API: http://localhost:8001
🧠 LM Studio: http://localhost:1234/v1
✓ LM Studio connected
✓ QuIXI connected
📍 Bot address: 1ABc2DEf3GHi4JKl5MNop...

🎯 Add this address as a contact in Spixi to start chatting!
Connected to MQTT broker with result code 0
🤖 AI Chatbot is ready!

You: What is the Ixian platform?
Bot: Ixian is a decentralized platform that enables peer-to-peer 
communication and transactions with post-quantum security. Unlike 
traditional blockchain networks, it focuses on scalable real-time 
communication through its S2 streaming layer...

You: Can you write Python code?
Bot: Yes! I can help with Python. What would you like to create?

You: Write a function to calculate fibonacci
Bot: Here's an efficient Python function for Fibonacci numbers:

def fibonacci(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

This uses O(n) time and O(1) space...

1. You send "What is AI?" in Spixi
   ↓
2. Spixi encrypts message (post-quantum)
   ↓
3. Routes through Ixian S2 network (P2P)
   ↓
4. QuIXI receives and decrypts
   ↓
5. Publishes to MQTT topic Chat/#
   ↓
6. Python bot receives message
   ↓
7. Bot sends to local LM Studio
   ↓
8. LM Studio processes with Llama 3
   ↓
9. Bot receives AI response
   ↓
10. Sends back through QuIXI -> S2 -> Spixi
    ↓
11. You see AI response (all P2P, all private)

# Support different models for different tasks
MODELS = {
    "chat": "llama-3-8b-instruct",
    "code": "codellama-13b",
    "creative": "mixtral-8x7b"
}

def get_ai_response(user_address, user_message, task="chat"):
    completion = client.chat.completions.create(
        model=MODELS[task],
        messages=conversation_history[user_address],
        temperature=0.7 if task == "chat" else 0.2
    )
    # ... rest of code

import sqlite3
from datetime import datetime

# Store conversations in SQLite
def save_conversation(address, role, message):
    conn = sqlite3.connect('conversations.db')
    c = conn.cursor()
    c.execute('''INSERT INTO messages (address, role, message, timestamp)
                 VALUES (?, ?, ?, ?)''',
              (address, role, message, datetime.now()))
    conn.commit()
    conn.close()

def load_conversation(address, limit=20):
    conn = sqlite3.connect('conversations.db')
    c = conn.cursor()
    c.execute('''SELECT role, message FROM messages 
                 WHERE address = ? 
                 ORDER BY timestamp DESC LIMIT ?''',
              (address, limit))
    messages = c.fetchall()
    conn.close()
    return [{"role": r, "content": m} for r, m in reversed(messages)]

from sentence_transformers import SentenceTransformer
import numpy as np

# Load embedding model
embedder = SentenceTransformer('all-MiniLM-L6-v2')

# Your knowledge base
knowledge_base = [
    "Ixian uses post-quantum cryptography including ML-KEM.",
    "QuIXI bridges traditional systems to the Ixian network.",
    # ... more documents
]

# Pre-compute embeddings
kb_embeddings = embedder.encode(knowledge_base)

def get_relevant_context(query, top_k=3):
    query_embedding = embedder.encode([query])
    similarities = np.dot(kb_embeddings, query_embedding.T).flatten()
    top_indices = similarities.argsort()[-top_k:][::-1]
    return "\n".join([knowledge_base[i] for i in top_indices])

def get_ai_response(user_address, user_message):
    # Add relevant context from knowledge base
    context = get_relevant_context(user_message)
    enhanced_message = f"Context:\n{context}\n\nQuestion: {user_message}"
    
    # ... rest of AI processing

# Define tools the AI can use
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"}
                }
            }
        }
    }
]

def get_weather(location):
    # Implementation here
    return f"Weather in {location}: Sunny, 72°F"

# In get_ai_response:
completion = client.chat.completions.create(
    model="local-model",
    messages=messages,
    tools=TOOLS,
    tool_choice="auto"
)

# Handle tool calls
if completion.choices[0].message.tool_calls:
    # Execute function and return result
    pass

# Create systemd service
sudo nano /etc/systemd/system/ai-bot.service

[Unit]
Description=Ixian AI Chatbot
After=network.target mosquitto.service

[Service]
Type=simple
User=youruser
WorkingDirectory=/home/youruser
ExecStart=/usr/bin/python3 /home/youruser/ai_chatbot.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

sudo systemctl enable ai-bot
sudo systemctl start ai-bot
sudo systemctl status ai-bot

import logging

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('bot.log'),
        logging.StreamHandler()
    ]
)

# Log all interactions
logging.info(f"User {sender[:8]}: {message}")
logging.info(f"Bot response: {ai_response[:100]}")