Mikail.Net

Yazılımcı günlüğü

Sesli AI Asistanı ile Bilgisayar Kontrolü: Kapsamlı Uygulama Rehberi

Bilgisayarınızı sesli komutlarla kontrol edebilen, AI ajanlarını (Claude Code CLI, Open Interpreter, Gemini gibi) birleştiren ve klavye-fare kullanımını minimize eden entegre bir sistem kurmanız için detaylı bir araştırma raporu hazırladım.

Önerilen Mimari ve Çözüm

Hibrit Sistem Mimarisi

Araştırmalarım sonucunda, güvenlik, performans ve Türkçe dil desteğini optimize eden aşağıdaki hibrit mimariyi öneriyorum:

┌─────────────────────────────────────────────────────────┐
│                    Sesli Giriş Katmanı                   │
│  • Picovoice Porcupine (Wake Word - "Hey Asistan")       │
│  • Google Speech-to-Text (Ana STT - Türkçe)              │
│  • OpenAI Whisper Turbo (Yedek/Offline)                  │
└─────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────┐
│                 Intent ve Orchestration                   │
│  • LangGraph (Karmaşık iş akışları)                      │
│  • CrewAI (Basit görevler)                               │
│  • Redis (Oturum yönetimi ve cache)                      │
└─────────────────────────────────────────────────────────┘
                              │
        ┌─────────────────────┼─────────────────────┐
        ▼                     ▼                     ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│ Claude        │   │ Open          │   │ LaVague       │
│ Computer Use  │   │ Interpreter   │   │ Browser       │
│ (Ekran        │   │ (Kod          │   │ (Web          │
│ kontrolü)     │   │ çalıştırma)   │   │ otomasyonu)   │
└───────────────┘   └───────────────┘   └───────────────┘

1. Ses Tanıma Katmanı Uygulaması

Ana Teknoloji Stack’i

Türkçe için optimize edilmiş ses tanıma sistemi:

class TurkishVoiceInterface:
    def __init__(self):
        # Wake word detection - Türkçe destekli
        self.porcupine = pvporcupine.create(
            access_key="PICOVOICE_API_KEY",
            keywords=['hey-asistan'],  # Özel Türkçe wake word
            sensitivities=[0.7]
        )
        
        # Google STT - Ana sistem (Türkçe)
        self.google_client = speech.SpeechClient()
        self.stream_config = speech.RecognitionConfig(
            encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
            sample_rate_hertz=16000,
            language_code="tr-TR",
            enable_automatic_punctuation=True,
            model="latest_long"
        )
        
        # Whisper - Yedek/Offline
        self.whisper_model = whisper.load_model("turbo")
        
    async def process_audio_stream(self, audio_stream):
        # Wake word algılama
        if self.porcupine.process(audio_stream) >= 0:
            print("Wake word algılandı!")
            
            try:
                # Önce Google STT dene
                text = await self.google_streaming_stt(audio_stream)
            except Exception as e:
                # Hata durumunda Whisper'a geç
                print(f"Google STT başarısız, Whisper'a geçiliyor: {e}")
                text = self.whisper_transcribe(audio_stream)
                
            return text

Türkçe Dil Desteği Optimizasyonları

Performans metrikleri ve öneriler:

  • Google Speech-to-Text: %92-95 Türkçe doğruluk, 200ms gecikme
  • Whisper Turbo: %88-90 Türkçe doğruluk, 300-500ms gecikme
  • VOSK (offline alternatif): %85 doğruluk, 50MB model boyutu

2. AI Ajan Entegrasyonu

Bilgisayar Kontrolü için Ajan Seçimi

En etkili kombinasyon:

class ComputerControlOrchestrator:
    def __init__(self):
        # Claude Computer Use - Ekran kontrolü
        self.claude_client = anthropic.Anthropic()
        
        # Open Interpreter - Kod çalıştırma
        self.interpreter = OpenInterpreter()
        self.interpreter.llm.model = "gpt-4o-mini"
        
        # LaVague - Tarayıcı otomasyonu
        self.browser_agent = WebAgent(
            WorldModel(),
            ActionEngine(SeleniumDriver())
        )
        
        # Ollama - Lokal LLM desteği (maliyet optimizasyonu)
        self.local_llm = ollama.Client()
    
    async def route_command(self, intent, entities):
        """Komutu uygun ajana yönlendir"""
        if intent == "screen_control":
            return await self.claude_computer_use(entities)
        elif intent == "code_execution":
            return await self.open_interpreter_execute(entities)
        elif intent == "browser_automation":
            return await self.lavague_browser(entities)
        else:
            return await self.local_llm_process(entities)

Claude Computer Use Entegrasyonu

Güvenli sandbox ortamında ekran kontrolü:

async def claude_computer_use(self, command):
    response = self.claude_client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=1024,
        tools=[{
            "type": "computer_20241022",
            "name": "computer",
            "display_width_px": 1920,
            "display_height_px": 1080
        }],
        messages=[{"role": "user", "content": command}],
        betas=["computer-use-2024-10-22"]
    )
    return response

3. Orchestration ve State Management

LangGraph ile Karmaşık İş Akışları

from langgraph.prebuilt import create_react_agent
from langchain_core.messages import HumanMessage

# Multi-agent orchestration
agent_executor = create_react_agent(
    model="gpt-4o",
    tools=[
        voice_command_tool,
        computer_control_tool,
        code_execution_tool,
        browser_automation_tool
    ],
    checkpointer=MemorySaver()  # Konuşma geçmişi
)

# Sesli komut işleme
async def process_voice_command(transcribed_text):
    response = await agent_executor.ainvoke(
        {"messages": [HumanMessage(content=transcribed_text)]},
        config={"configurable": {"thread_id": "user_session_123"}}
    )
    return response

Redis ile Oturum Yönetimi

import redis
import json

class SessionManager:
    def __init__(self):
        self.redis_client = redis.Redis(
            host='localhost',
            port=6379,
            decode_responses=True
        )
        
    def save_context(self, session_id, context):
        # Konuşma bağlamını sakla
        self.redis_client.setex(
            f"session:{session_id}",
            3600,  # 1 saat TTL
            json.dumps(context)
        )
    
    def get_context(self, session_id):
        context = self.redis_client.get(f"session:{session_id}")
        return json.loads(context) if context else {}

4. Docker-based Güvenli Deployment

Production-Ready Docker Compose

version: '3.8'

services:
  voice-assistant:
    build: ./voice-assistant
    ports:
      - "8000:8000"
    environment:
      - GOOGLE_APPLICATION_CREDENTIALS=/app/credentials.json
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    volumes:
      - ./models:/app/models
      - /tmp/.X11-unix:/tmp/.X11-unix:rw
    devices:
      - /dev/snd:/dev/snd  # Ses cihazı erişimi
    runtime: nvidia  # GPU desteği
    deploy:
      resources:
        limits:
          cpus: '4'
          memory: 8G
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    security_opt:
      - seccomp:securityprofile.json
      - no-new-privileges:true
    networks:
      - assistant-network

  whisper-stt:
    image: onerahmet/openai-whisper-asr-webservice:latest-gpu
    ports:
      - "9000:9000"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    networks:
      - assistant-network

  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ./ollama-models:/root/.ollama
    deploy:
      resources:
        limits:
          memory: 16G
    networks:
      - assistant-network

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - assistant-network

  code-executor:
    build: ./code-executor
    security_opt:
      - seccomp:unconfined
    runtime: runsc  # gVisor for enhanced isolation
    read_only: true
    tmpfs:
      - /tmp
      - /var/tmp
    networks:
      - assistant-network

networks:
  assistant-network:
    driver: bridge

volumes:
  redis-data:

5. WebSocket Tabanlı Gerçek Zamanlı İletişim

FastAPI + WebSocket Server

from fastapi import FastAPI, WebSocket
import asyncio

app = FastAPI()

class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []
        self.voice_interface = TurkishVoiceInterface()
        self.orchestrator = ComputerControlOrchestrator()
    
    async def process_audio_stream(self, websocket: WebSocket, audio_data):
        # Ses tanıma
        text = await self.voice_interface.process_audio_stream(audio_data)
        
        # Intent analizi ve routing
        intent, entities = await self.analyze_intent(text)
        
        # Komutu ilgili ajana yönlendir
        result = await self.orchestrator.route_command(intent, entities)
        
        # Sonucu kullanıcıya gönder
        await websocket.send_json({
            "transcribed_text": text,
            "intent": intent,
            "result": result,
            "status": "completed"
        })

@app.websocket("/ws/voice")
async def voice_endpoint(websocket: WebSocket):
    await websocket.accept()
    manager = ConnectionManager()
    
    try:
        while True:
            # Audio stream al
            audio_data = await websocket.receive_bytes()
            
            # Asenkron olarak işle
            asyncio.create_task(
                manager.process_audio_stream(websocket, audio_data)
            )
    except Exception as e:
        print(f"WebSocket hatası: {e}")
    finally:
        await websocket.close()

6. Performans Optimizasyonu

Hedef Metrikler ve Optimizasyon

Toplam gecikme hedefi: <800ms

  • Ses tanıma: 150-200ms
  • LLM işleme: 300-400ms
  • TTS: 100-150ms
  • Ağ gecikmesi: 50-100ms
class PerformanceOptimizer:
    def __init__(self):
        self.cache = {}
        self.semantic_cache = SemanticCache()
        
    async def optimized_processing(self, audio_chunk):
        # Paralel işleme
        tasks = [
            self.process_stt(audio_chunk),
            self.prepare_context(),
            self.warm_tts_cache()
        ]
        
        # Concurrent execution
        results = await asyncio.gather(*tasks)
        
        # Semantic caching - %40-60 LLM çağrı azaltımı
        cached_response = self.semantic_cache.get_similar(results[0])
        if cached_response:
            return cached_response
        
        # Process with LLM
        response = await self.process_with_llm(results)
        self.semantic_cache.store(results[0], response)
        
        return response

7. Güvenlik Implementasyonu

Çok Katmanlı Güvenlik Mimarisi

class SecurityLayer:
    def __init__(self):
        self.voice_auth = VoiceAuthenticator()
        self.command_validator = CommandValidator()
        self.sandbox = DockerSandbox()
        
    async def secure_execute(self, user_voice, command):
        # Ses kimlik doğrulama
        if not self.voice_auth.verify_speaker(user_voice):
            raise SecurityError("Ses doğrulama başarısız")
        
        # Komut validasyonu
        if not self.command_validator.is_safe(command):
            raise SecurityError("Güvenli olmayan komut algılandı")
        
        # Sandbox içinde çalıştır
        result = await self.sandbox.execute(
            command,
            memory_limit="512m",
            cpu_quota=50000,
            network_disabled=True,
            timeout=30
        )
        
        return result

8. Pratik Kurulum Adımları

Adım 1: Geliştirme Ortamı Hazırlığı

# 1. Repository klonlama
git clone https://github.com/your-repo/voice-ai-assistant
cd voice-ai-assistant

# 2. Python environment
python -m venv venv
source venv/bin/activate  # Linux/Mac
# veya
venv\Scripts\activate  # Windows

# 3. Bağımlılıkları yükle
pip install -r requirements.txt

# 4. Docker ortamını hazırla
docker-compose build

Adım 2: API Anahtarları Konfigürasyonu

# .env dosyası oluştur
cat > .env << EOF
OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
GOOGLE_APPLICATION_CREDENTIALS=./credentials.json
PICOVOICE_ACCESS_KEY=your_picovoice_key
ELEVENLABS_API_KEY=your_elevenlabs_key
EOF

Adım 3: Türkçe Model İndirme

# Whisper Türkçe modeli
python -c "import whisper; whisper.load_model('turbo')"

# VOSK Türkçe modeli (alternatif)
wget https://alphacephei.com/vosk/models/vosk-model-tr-0.3.zip
unzip vosk-model-tr-0.3.zip

# Ollama için lokal model
docker exec ollama ollama pull codellama:13b

Adım 4: Sistemi Başlatma

# Tüm servisleri başlat
docker-compose up -d

# Logları kontrol et
docker-compose logs -f

# Health check
curl http://localhost:8000/health

9. Monitoring ve Maintenance

Production Monitoring Stack

# Sentry entegrasyonu - AI-specific error tracking
import sentry_sdk
from sentry_sdk.integrations.fastapi import FastApiIntegration

sentry_sdk.init(
    dsn="YOUR_SENTRY_DSN",
    integrations=[FastApiIntegration()],
    traces_sample_rate=0.1,
    profiles_sample_rate=0.1,
)

# Custom metrics
@app.middleware("http")
async def track_performance(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    
    # Track response time
    process_time = time.time() - start_time
    
    # Alert if exceeds SLA
    if process_time > 0.8:  # 800ms threshold
        sentry_sdk.capture_message(
            f"Slow response: {process_time:.2f}s",
            level="warning"
        )
    
    return response

10. Maliyet Analizi

Aylık Operasyonel Maliyetler

Bulut Servisleri:

  • Google Speech-to-Text: $50-100/ay (ortalama kullanım)
  • OpenAI API: $100-200/ay (GPT-4o-mini kullanımı)
  • Claude API: $50-100/ay (Computer Use için)
  • Toplam: $200-400/ay

Lokal Alternatif (Tek seferlik yatırım):

  • GPU’lu workstation: $3000-5000
  • Elektrik maliyeti: $30-50/ay
  • Bakım: Minimal
  • 6-12 ayda kendini amorti eder

Alternatif Çözümler

1. Hazır Platformlar

  • Talon Voice ($15/ay): Programlama odaklı, güçlü komut sistemi
  • OVOS (Open Voice OS): Açık kaynak, gizlilik odaklı
  • Voice Attack ($10 tek seferlik): Basit otomasyon için

2. Türkçe İçin Özel Optimizasyonlar

  • VOSK kullanarak tamamen offline çalışma
  • Hibrit yaklaşım: Teknik terimler için İngilizce, genel komutlar için Türkçe
  • Custom wake word eğitimi ile kişiselleştirme

Sonuç ve Öneriler

Bu araştırma sonucunda, WebSocket tabanlı gerçek zamanlı iletişim, LangGraph orchestration, ve hibrit bulut/lokal işleme kombinasyonunun en optimal çözüm olduğunu belirledim. Sistem, Türkçe için %88-95 doğruluk oranı ve 800ms altı gecikme ile çalışabilir.

Başlangıç için önerilerim:

  1. Google STT + Whisper backup ile hibrit ses tanıma
  2. CrewAI ile basit orchestration (sonra LangGraph’a geçiş)
  3. Docker-based güvenli deployment
  4. Semantic caching ile maliyet optimizasyonu

Bu mimari, güvenlik, performans ve maliyet dengesini koruyarak, klavye-fare kullanımını minimize eden etkili bir sesli AI asistan sistemi sağlar.