agentkit-sdk 0.1.0__py3-none-any.whl

agentkit/__init__.py

@@ -0,0 +1,3 @@
+"""AgentKit - Developer SDK for building personalized voice AI assistants"""
+
+__version__ = "0.1.0"

agentkit/cli/build.py

@@ -0,0 +1,54 @@
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import click
+
+
+@click.command()
+@click.option("--config", default="agent.config.yaml", help="Config file path")
+@click.option("--output", default="build/", help="Output directory")
+def android(config: str, output: str):
+    """Build Android APK from AgentShell template."""
+    
+    if not Path(config).exists():
+        click.echo(f"Error: Config file '{config}' not found.")
+        sys.exit(1)
+    
+    click.echo("Building Android APK...")
+    
+    import yaml
+    with open(config) as f:
+        cfg = yaml.safe_load(f)
+    
+    agent_name = cfg.get("agent", {}).get("name", "Agent")
+    backend_url = cfg.get("deployment", {}).get("backend_url", "ws://localhost:8000/ws/voice")
+    
+    template_dir = Path(__file__).parent.parent / "mobile" / "AgentShell"
+    
+    if not template_dir.exists():
+        click.echo("Error: AgentShell template not found.")
+        sys.exit(1)
+    
+    project_dir = Path(output)
+    project_dir.mkdir(parents=True, exist_ok=True)
+    
+    shutil.copytree(template_dir, project_dir / "AgentShell", dirs_exist_ok=True)
+    
+    app_js = project_dir / "AgentShell" / "App.jsx"
+    if app_js.exists():
+        content = app_js.read_text()
+        content = content.replace("ws://localhost:8000/ws/voice", backend_url)
+        content = content.replace("Assistant", agent_name)
+        app_js.write_text(content)
+    
+    click.echo("Installing dependencies...")
+    os.chdir(project_dir / "AgentShell")
+    subprocess.run(["npm", "install"], check=True)
+    
+    click.echo("Building Android APK...")
+    subprocess.run(["npx", "expo", "run:android"], check=True)
+    
+    click.echo(f"APK built at: {project_dir / "AgentShell/android/app/build/outputs/apk/release/"}")

agentkit/cli/deploy.py

@@ -0,0 +1,50 @@
+import subprocess
+import sys
+
+import click
+
+
+PLATFORMS = ["railway", "render"]
+
+
+@click.command()
+@click.option("--platform", type=click.Choice(PLATFORMS), required=True, help="Deployment platform")
+@click.option("--config", default="agent.config.yaml", help="Config file path")
+def deploy(platform: str, config: str):
+    """Deploy backend to Railway or Render."""
+    
+    click.echo(f"Deploying to {platform}...")
+    
+    if platform == "railway":
+        _deploy_railway()
+    elif platform == "render":
+        _deploy_render()
+
+
+def _deploy_railway():
+    try:
+        result = subprocess.run(["railway", "login"], capture_output=True)
+        if result.returncode != 0:
+            click.echo("Please install Railway CLI: npm install -g @railway/cli")
+            sys.exit(1)
+        
+        subprocess.run(["railway", "init"], check=True)
+        subprocess.run(["railway", "up"], check=True)
+        
+        click.echo("Deployed to Railway! Run 'railway link' to connect.")
+    except FileNotFoundError:
+        click.echo("Railway CLI not found. Install with: npm install -g @railway/cli")
+
+
+def _deploy_render():
+    try:
+        result = subprocess.run(["render", "--version"], capture_output=True)
+        if result.returncode != 0:
+            click.echo("Please install Render CLI: npm install -g render-cli")
+            sys.exit(1)
+        
+        subprocess.run(["render", "blueprint", "init"], check=True)
+        
+        click.echo("Deployed to Render! Check your dashboard for the live URL.")
+    except FileNotFoundError:
+        click.echo("Render CLI not found. Install with: npm install -g render-cli")

agentkit/cli/init.py

@@ -0,0 +1,85 @@
+import os
+import shutil
+from pathlib import Path
+
+import click
+import yaml
+
+
+@click.command()
+@click.option("--name", default="my-agent", help="Agent name")
+@click.option("--output-dir", default=".", help="Output directory")
+def init(name: str, output_dir: str):
+    """Initialize a new AgentKit project."""
+    
+    project_dir = Path(output_dir) / name
+    project_dir.mkdir(parents=True, exist_ok=True)
+    
+    config_content = {
+        "agent": {
+            "name": name,
+            "persona": "You are a helpful personal assistant that remembers conversations and learns from corrections.",
+            "language": "hinglish"
+        },
+        "voice": {
+            "enabled": True,
+            "stt": {
+                "provider": "sarvam",
+                "api_key": "${SARVAM_API_KEY}"
+            },
+            "tts": {
+                "provider": "sarvam",
+                "voice": "meera",
+                "api_key": "${SARVAM_API_KEY}"
+            }
+        },
+        "llm": {
+            "provider": "gemini",
+            "model": "gemini-2.0-flash",
+            "api_key": "${GEMINI_API_KEY}",
+            "temperature": 0.7
+        },
+        "memory": {
+            "type": "markdown",
+            "backend": "local",
+            "episodic_window": 20,
+            "semantic_top_k": 5
+        },
+        "learning": {
+            "enabled": True,
+            "correction_detection": True,
+            "implicit_feedback": True,
+            "profile_extraction": True
+        },
+        "deployment": {
+            "type": "self-host",
+            "port": 8000
+        }
+    }
+    
+    config_path = project_dir / "agent.config.yaml"
+    with open(config_path, "w") as f:
+        yaml.dump(config_content, f, default_flow_style=False)
+    
+    env_example = """# API Keys
+SARVAM_API_KEY=your_sarvam_key
+GEMINI_API_KEY=your_gemini_key
+DEEPGRAM_API_KEY=your_deepgram_key
+ELEVENLABS_API_KEY=your_elevenlabs_key
+OPENAI_API_KEY=your_openai_key
+"""
+    
+    env_path = project_dir / ".env.example"
+    with open(env_path, "w") as f:
+        f.write(env_example)
+    
+    src_dir = project_dir / "src"
+    src_dir.mkdir(exist_ok=True)
+    
+    (src_dir / "__init__.py").touch()
+    
+    click.echo(f"AgentKit project '{name}' created at {project_dir}")
+    click.echo(f"Next steps:")
+    click.echo(f"  1. cd {project_dir}")
+    click.echo(f"  2. cp .env.example .env and add your API keys")
+    click.echo(f"  3. agentkit serve")

agentkit/cli/main.py

@@ -0,0 +1,22 @@
+import click
+
+from agentkit.cli.init import init
+from agentkit.cli.serve import serve
+from agentkit.cli.build import android
+from agentkit.cli.deploy import deploy
+
+
+@click.group()
+def cli():
+    """AgentKit - Build personalized voice AI assistants"""
+    pass
+
+
+cli.add_command(init)
+cli.add_command(serve)
+cli.add_command(android)
+cli.add_command(deploy)
+
+
+if __name__ == "__main__":
+    cli()

agentkit/cli/serve.py

@@ -0,0 +1,35 @@
+import os
+import sys
+from pathlib import Path
+
+import click
+from dotenv import load_dotenv
+
+
+@click.command()
+@click.option("--config", default="agent.config.yaml", help="Config file path")
+@click.option("--port", default=8000, help="Server port")
+@click.option("--reload", is_flag=True, help="Enable auto-reload")
+def serve(config: str, port: int, reload: bool):
+    """Start the AgentKit server."""
+    
+    if not Path(config).exists():
+        click.echo(f"Error: Config file '{config}' not found.")
+        click.echo("Run 'agentkit init' first to create a project.")
+        sys.exit(1)
+    
+    load_dotenv()
+    
+    import uvicorn
+    from agentkit.server.app import app
+    
+    click.echo(f"Starting AgentKit server on port {port}...")
+    click.echo(f"Playground available at http://localhost:{port}/playground")
+    
+    uvicorn.run(
+        "agentkit.server.app:app",
+        host="0.0.0.0",
+        port=port,
+        reload=reload,
+        env_file=".env",
+    )

agentkit/core/__init__.py

@@ -0,0 +1,3 @@
+from .pipeline import VoicePipeline, PipelineConfig, Turn
+from .context import ContextAssembler, MemoryContext
+from .turn_detector import TurnDetector

agentkit/core/context.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class MemoryContext:
+    user_profile_summary: str = ""
+    semantic_episodes: str = ""
+    correction_rules: str = ""
+    recent_turns: str = ""
+
+    def assemble(self) -> str:
+        parts = []
+        if self.user_profile_summary:
+            parts.append(f"User Profile:\n{self.user_profile_summary}")
+        if self.semantic_episodes:
+            parts.append(f"Relevant History:\n{self.semantic_episodes}")
+        if self.correction_rules:
+            parts.append(f"Correction Rules:\n{self.correction_rules}")
+        if self.recent_turns:
+            parts.append(f"Recent Conversation:\n{self.recent_turns}")
+        return "\n\n".join(parts)
+
+
+class ContextAssembler:
+    def __init__(self, memory):
+        self.memory = memory
+
+    async def assemble(self, query: str, user_id: str) -> MemoryContext:
+        context = MemoryContext()
+        
+        user_model = await self.memory.get_user_model(user_id)
+        if user_model:
+            context.user_profile_summary = self._summarize_user_model(user_model)
+        
+        semantic_results = await self.memory.retrieve(query, user_id)
+        if semantic_results:
+            context.semantic_episodes = self._format_semantic_results(semantic_results)
+        
+        if user_model and user_model.correction_rules:
+            context.correction_rules = self._format_corrections(user_model.correction_rules)
+        
+        recent_turns = await self.memory.get_recent_turns(user_id, limit=20)
+        if recent_turns:
+            context.recent_turns = self._format_recent_turns(recent_turns)
+        
+        return context
+
+    def _summarize_user_model(self, user_model) -> str:
+        parts = [f"Name: {user_model.name}"]
+        if user_model.communication_style:
+            parts.append(f"Style: {user_model.communication_style}")
+        if user_model.inferred_interests:
+            parts.append(f"Interests: {', '.join(user_model.inferred_interests[:5])}")
+        if user_model.stated_goals:
+            parts.append(f"Goals: {', '.join(user_model.stated_goals[:3])}")
+        return "\n".join(parts)
+
+    def _format_semantic_results(self, results: list) -> str:
+        formatted = []
+        for r in results[:5]:
+            formatted.append(f"- {r.get('content', '')[:200]}")
+        return "\n".join(formatted)
+
+    def _format_corrections(self, corrections: list) -> str:
+        formatted = []
+        for c in corrections[:10]:
+            formatted.append(f"- {c.get('rule', '')}")
+        return "\n".join(formatted)
+
+    def _format_recent_turns(self, turns: list) -> str:
+        formatted = []
+        for turn in turns:
+            formatted.append(f"User: {turn.get('user_message', '')}")
+            formatted.append(f"Assistant: {turn.get('assistant_message', '')}")
+        return "\n".join(formatted[-40:])

agentkit/core/pipeline.py

@@ -0,0 +1,132 @@
+import asyncio
+from dataclasses import dataclass, field
+from typing import AsyncIterator
+
+from agentkit.providers.llm import BaseLLM, Message
+from agentkit.providers.stt import BaseSTT
+from agentkit.providers.tts import BaseTTS
+
+
+@dataclass
+class Turn:
+    user_message: str
+    assistant_message: str
+    timestamp: float
+
+
+@dataclass
+class PipelineConfig:
+    persona: str
+    language: str = "hinglish"
+    sentence_endings: list[str] = field(default_factory=lambda: ['.', '!', '?', '।'])
+
+
+class VoicePipeline:
+    def __init__(
+        self,
+        stt: BaseSTT,
+        llm: BaseLLM,
+        tts: BaseTTS,
+        config: PipelineConfig,
+    ):
+        self.stt = stt
+        self.llm = llm
+        self.tts = tts
+        self.config = config
+        self.conversation_history: list[Message] = []
+        self.turns: list[Turn] = []
+
+    async def process_voice_stream(
+        self,
+        audio_stream: AsyncIterator[bytes],
+        memory_context: str = ""
+    ) -> AsyncIterator[bytes]:
+        """Main streaming pipeline: STT → LLM → TTS with sentence-level streaming."""
+        
+        transcription = ""
+        async for text in self.stt.transcribe_stream(audio_stream):
+            transcription += text
+        
+        if not transcription.strip():
+            return
+        
+        self.conversation_history.append(Message(role="user", content=transcription))
+        
+        llm_stream = self.llm.chat_stream(
+            messages=self.conversation_history,
+            system=self.config.persona,
+            memory_context=memory_context,
+        )
+        
+        sentence_buffer = ""
+        async for token in llm_stream:
+            sentence_buffer += token
+            
+            if self._is_sentence_end(sentence_buffer) and len(sentence_buffer) >= 10:
+                tts_stream = self.tts.synthesize_stream(sentence_buffer)
+                async for audio_chunk in tts_stream:
+                    yield audio_chunk
+                sentence_buffer = ""
+        
+        if sentence_buffer.strip():
+            tts_stream = self.tts.synthesize_stream(sentence_buffer)
+            async for audio_chunk in tts_stream:
+                yield audio_chunk
+        
+        assistant_response = self._get_full_response()
+        self.conversation_history.append(Message(role="assistant", content=assistant_response))
+        self.turns.append(Turn(user_message=transcription, assistant_message=assistant_response))
+
+    async def process_text(
+        self,
+        user_message: str,
+        memory_context: str = ""
+    ) -> AsyncIterator[bytes]:
+        """Process text input and stream audio response."""
+        
+        self.conversation_history.append(Message(role="user", content=user_message))
+        
+        llm_stream = self.llm.chat_stream(
+            messages=self.conversation_history,
+            system=self.config.persona,
+            memory_context=memory_context,
+        )
+        
+        sentence_buffer = ""
+        async for token in llm_stream:
+            sentence_buffer += token
+            
+            if self._is_sentence_end(sentence_buffer) and len(sentence_buffer) >= 10:
+                tts_stream = self.tts.synthesize_stream(sentence_buffer)
+                async for audio_chunk in tts_stream:
+                    yield audio_chunk
+                sentence_buffer = ""
+        
+        if sentence_buffer.strip():
+            tts_stream = self.tts.synthesize_stream(sentence_buffer)
+            async for audio_chunk in tts_stream:
+                yield audio_chunk
+        
+        assistant_response = self._get_full_response()
+        self.conversation_history.append(Message(role="assistant", content=assistant_response))
+        self.turns.append(Turn(user_message=user_message, assistant_message=assistant_response))
+
+    def _is_sentence_end(self, text: str) -> bool:
+        for ending in self.config.sentence_endings:
+            if text.rstrip().endswith(ending):
+                return True
+        return False
+
+    def _get_full_response(self) -> str:
+        return " ".join([
+            m.content for m in self.conversation_history 
+            if m.role == "assistant"
+        ])
+
+    def get_recent_turns(self, count: int = 20) -> list[Turn]:
+        return self.turns[-count:]
+
+    async def close(self):
+        await self.stt.close()
+        await self.llm.close()
+        await self.tts.close()

agentkit/core/turn_detector.py

@@ -0,0 +1,49 @@
+import asyncio
+from typing import AsyncIterator
+
+
+class TurnDetector:
+    def __init__(
+        self,
+        silence_threshold: float = 1.5,
+        energy_threshold: float = 0.01,
+    ):
+        self.silence_threshold = silence_threshold
+        self.energy_threshold = energy_threshold
+
+    async def detect_turn_end(
+        self,
+        audio_stream: AsyncIterator[bytes],
+        sample_rate: int = 16000
+    ) -> AsyncIterator[bytes]:
+        """Detect when user has finished speaking based on silence."""
+        
+        buffer = bytearray()
+        silence_duration = 0.0
+        chunk_duration = 0.02
+        bytes_per_chunk = int(sample_rate * chunk_duration * 2)
+        
+        async for chunk in audio_stream:
+            buffer.extend(chunk)
+            
+            energy = self._calculate_energy(bytes(chunk[-bytes_per_chunk:]))
+            
+            if energy < self.energy_threshold:
+                silence_duration += chunk_duration
+                if silence_duration >= self.silence_threshold:
+                    if buffer[:-bytes_per_chunk]:
+                        yield bytes(buffer[:-bytes_per_chunk])
+                    buffer.clear()
+                    break
+            else:
+                silence_duration = 0.0
+        
+        if buffer:
+            yield bytes(buffer)
+
+    def _calculate_energy(self, audio_bytes: bytes) -> float:
+        if not audio_bytes:
+            return 0.0
+        import struct
+        samples = struct.unpack(f"{len(audio_bytes)//2}h", audio_bytes)
+        return sum(abs(s) for s in samples) / len(samples) / 32768.0

agentkit/learning/__init__.py

@@ -0,0 +1,2 @@
+from .correction import CorrectionDetector, CorrectionStore, DetectedCorrection
+from .recommender import ProactiveRecommender

agentkit/learning/correction.py

@@ -0,0 +1,109 @@
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+
+EXPLICIT_PATTERNS = [
+    "that's wrong", "not correct", "actually", "I said", "no wait",
+    "wrong", "incorrect", "that's not right", "I meant", "forget that",
+]
+
+
+@dataclass
+class DetectedCorrection:
+    type: str
+    rule: str
+    original_intent: str
+    corrected_intent: str
+    confidence: float
+    turn_id: str
+
+
+class CorrectionDetector:
+    def __init__(self):
+        self.last_user_query = ""
+        self.last_agent_response_time = 0.0
+
+    def detect_explicit(self, user_message: str) -> DetectedCorrection | None:
+        """Detect explicit corrections like 'that's wrong', 'not correct'."""
+        user_lower = user_message.lower()
+        
+        for pattern in EXPLICIT_PATTERNS:
+            if pattern in user_lower:
+                return DetectedCorrection(
+                    type="explicit",
+                    rule=f"Never: {pattern}",
+                    original_intent="",
+                    corrected_intent=user_message,
+                    confidence=0.9,
+                    turn_id=str(int(time.time())),
+                )
+        
+        return None
+
+    def detect_implicit(
+        self,
+        user_message: str,
+        response_time: float,
+        last_user_query: str | None = None
+    ) -> DetectedCorrection | None:
+        """Detect implicit corrections - user rephrases after agent response."""
+        
+        if last_user_query is None:
+            last_user_query = self.last_user_query
+        
+        if response_time < 4.0 and last_user_query:
+            similarity = self._cosine_similarity(user_message, last_user_query)
+            
+            if similarity > 0.8:
+                return DetectedCorrection(
+                    type="implicit",
+                    rule="User rephrased - original intent was X not Y",
+                    original_intent=last_user_query,
+                    corrected_intent=user_message,
+                    confidence=0.7,
+                    turn_id=str(int(time.time())),
+                )
+        
+        return None
+
+    def _cosine_similarity(self, text1: str, text2: str) -> float:
+        words1 = set(text1.lower().split())
+        words2 = set(text2.lower().split())
+        
+        if not words1 or not words2:
+            return 0.0
+        
+        intersection = words1 & words2
+        union = words1 | words2
+        
+        return len(intersection) / len(union) if union else 0.0
+
+    def update_context(self, user_message: str):
+        self.last_user_query = user_message
+        self.last_agent_response_time = time.time()
+
+
+class CorrectionStore:
+    def __init__(self, memory):
+        self.memory = memory
+
+    async def store_correction(self, correction: DetectedCorrection, user_id: str):
+        from agentkit.memory.base import Correction
+        
+        rule = Correction(
+            rule=correction.rule,
+            original_intent=correction.original_intent,
+            corrected_intent=correction.corrected_intent,
+            source_turn_id=correction.turn_id,
+            created_at=datetime.now(),
+        )
+        
+        user_model = await self.memory.get_user_model(user_id)
+        if user_model:
+            user_model.correction_rules.append(rule)
+            await self.memory.update_user_model(
+                user_id,
+                correction_rules=user_model.correction_rules
+            )