neuroagent 1.3.0

package/neuroagent/frontend/widget.js

@@ -0,0 +1,409 @@
+/**
+ * NeuroAgent Widget - JavaScript widget for integrating AI agents on websites
+ * Version: 0.1.0
+ */
+
+(function(global) {
+    'use strict';
+
+    class NeuroAgentWidget {
+        constructor(config) {
+            this.config = {
+                apiUrl: config.apiUrl || 'http://localhost:8000',
+                agent: config.agent || 'default',
+                wsUrl: config.wsUrl || null,
+                theme: config.theme || 'dark',
+                position: config.position || 'bottom-right',
+                title: config.title || 'AI Assistant',
+                welcomeMessage: config.welcomeMessage || 'Hello! How can I help you today?',
+                ...config
+            };
+            
+            this.isOpen = false;
+            this.messages = [];
+            this.websocket = null;
+            
+            this.init();
+        }
+        
+        init() {
+            this.createStyles();
+            this.createWidget();
+            this.createChatContainer();
+            this.bindEvents();
+            
+            if (this.config.wsUrl) {
+                this.connectWebSocket();
+            }
+        }
+        
+        createStyles() {
+            const styles = document.createElement('style');
+            styles.textContent = `
+                .neuroagent-widget {
+                    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                    position: fixed;
+                    z-index: 999999;
+                }
+                
+                .neuroagent-widget-button {
+                    width: 60px;
+                    height: 60px;
+                    border-radius: 50%;
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    border: none;
+                    cursor: pointer;
+                    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4);
+                    display: flex;
+                    align-items: center;
+                    justify-content: center;
+                    transition: transform 0.3s ease;
+                }
+                
+                .neuroagent-widget-button:hover {
+                    transform: scale(1.1);
+                }
+                
+                .neuroagent-widget-button svg {
+                    width: 30px;
+                    height: 30px;
+                    fill: white;
+                }
+                
+                .neuroagent-chat {
+                    position: fixed;
+                    width: 380px;
+                    height: 500px;
+                    background: white;
+                    border-radius: 16px;
+                    box-shadow: 0 10px 40px rgba(0, 0, 0, 0.2);
+                    display: none;
+                    flex-direction: column;
+                    overflow: hidden;
+                }
+                
+                .neuroagent-chat.open {
+                    display: flex;
+                }
+                
+                .neuroagent-chat-header {
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                    padding: 16px;
+                    display: flex;
+                    align-items: center;
+                    justify-content: space-between;
+                }
+                
+                .neuroagent-chat-title {
+                    font-weight: 600;
+                    font-size: 16px;
+                }
+                
+                .neuroagent-chat-close {
+                    background: none;
+                    border: none;
+                    color: white;
+                    cursor: pointer;
+                    font-size: 20px;
+                    padding: 0;
+                    line-height: 1;
+                }
+                
+                .neuroagent-chat-messages {
+                    flex: 1;
+                    padding: 16px;
+                    overflow-y: auto;
+                    display: flex;
+                    flex-direction: column;
+                    gap: 12px;
+                }
+                
+                .neuroagent-message {
+                    max-width: 80%;
+                    padding: 12px 16px;
+                    border-radius: 16px;
+                    font-size: 14px;
+                    line-height: 1.5;
+                }
+                
+                .neuroagent-message.user {
+                    align-self: flex-end;
+                    background: #667eea;
+                    color: white;
+                    border-bottom-right-radius: 4px;
+                }
+                
+                .neuroagent-message.assistant {
+                    align-self: flex-start;
+                    background: #f0f0f0;
+                    color: #333;
+                    border-bottom-left-radius: 4px;
+                }
+                
+                .neuroagent-message.thinking {
+                    align-self: flex-start;
+                    background: #f0f0f0;
+                    color: #666;
+                    font-style: italic;
+                }
+                
+                .neuroagent-chat-input {
+                    padding: 16px;
+                    border-top: 1px solid #eee;
+                    display: flex;
+                    gap: 8px;
+                }
+                
+                .neuroagent-chat-input input {
+                    flex: 1;
+                    padding: 12px 16px;
+                    border: 1px solid #ddd;
+                    border-radius: 24px;
+                    outline: none;
+                    font-size: 14px;
+                }
+                
+                .neuroagent-chat-input input:focus {
+                    border-color: #667eea;
+                }
+                
+                .neuroagent-chat-input button {
+                    background: #667eea;
+                    color: white;
+                    border: none;
+                    padding: 12px 20px;
+                    border-radius: 24px;
+                    cursor: pointer;
+                    font-size: 14px;
+                    font-weight: 500;
+                    transition: background 0.3s ease;
+                }
+                
+                .neuroagent-chat-input button:hover {
+                    background: #5568d3;
+                }
+                
+                .neuroagent-chat-input button:disabled {
+                    background: #ccc;
+                    cursor: not-allowed;
+                }
+                
+                .neuroagent-position-bottom-right {
+                    bottom: 20px;
+                    right: 20px;
+                }
+                
+                .neuroagent-position-bottom-left {
+                    bottom: 20px;
+                    left: 20px;
+                }
+                
+                .neuroagent-position-top-right {
+                    top: 20px;
+                    right: 20px;
+                }
+                
+                .neuroagent-position-top-left {
+                    top: 20px;
+                    left: 20px;
+                }
+                
+                .neuroagent-chat.neuroagent-position-bottom-right,
+                .neuroagent-chat.neuroagent-position-bottom-left {
+                    bottom: 90px;
+                }
+                
+                .neuroagent-chat.neuroagent-position-top-right,
+                .neuroagent-chat.neuroagent-position-top-left {
+                    top: 90px;
+                }
+                
+                .neuroagent-chat.neuroagent-position-bottom-right,
+                .neuroagent-chat.neuroagent-position-top-right {
+                    right: 20px;
+                }
+                
+                .neuroagent-chat.neuroagent-position-bottom-left,
+                .neuroagent-chat.neuroagent-position-top-left {
+                    left: 20px;
+                }
+            `;
+            
+            document.head.appendChild(styles);
+        }
+        
+        createWidget() {
+            this.widget = document.createElement('div');
+            this.widget.className = `neuroagent-widget neuroagent-position-${this.config.position}`;
+            
+            this.widget.innerHTML = `
+                <button class="neuroagent-widget-button" title="${this.config.title}">
+                    <svg viewBox="0 0 24 24">
+                        <path d="M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 14H6l-2 2V4h16v12z"/>
+                        <path d="M7 9h10v2H7zm0-3h10v2H7z"/>
+                    </svg>
+                </button>
+            `;
+            
+            document.body.appendChild(this.widget);
+        }
+        
+        createChatContainer() {
+            this.chatContainer = document.createElement('div');
+            this.chatContainer.className = `neuroagent-chat neuroagent-position-${this.config.position}`;
+            this.chatContainer.innerHTML = `
+                <div class="neuroagent-chat-header">
+                    <span class="neuroagent-chat-title">${this.config.title}</span>
+                    <button class="neuroagent-chat-close">&times;</button>
+                </div>
+                <div class="neuroagent-chat-messages"></div>
+                <div class="neuroagent-chat-input">
+                    <input type="text" placeholder="Type a message..." />
+                    <button>Send</button>
+                </div>
+            `;
+            
+            document.body.appendChild(this.chatContainer);
+            
+            this.messagesContainer = this.chatContainer.querySelector('.neuroagent-chat-messages');
+            this.inputField = this.chatContainer.querySelector('input');
+            this.sendButton = this.chatContainer.querySelector('button');
+            
+            this.addMessage(this.config.welcomeMessage, 'assistant');
+        }
+        
+        bindEvents() {
+            const button = this.widget.querySelector('.neuroagent-widget-button');
+            const closeButton = this.chatContainer.querySelector('.neuroagent-chat-close');
+            
+            button.addEventListener('click', () => this.toggle());
+            closeButton.addEventListener('click', () => this.close());
+            
+            this.sendButton.addEventListener('click', () => this.sendMessage());
+            this.inputField.addEventListener('keypress', (e) => {
+                if (e.key === 'Enter') {
+                    this.sendMessage();
+                }
+            });
+        }
+        
+        toggle() {
+            this.isOpen ? this.close() : this.open();
+        }
+        
+        open() {
+            this.isOpen = true;
+            this.chatContainer.classList.add('open');
+            this.inputField.focus();
+        }
+        
+        close() {
+            this.isOpen = false;
+            this.chatContainer.classList.remove('open');
+        }
+        
+        addMessage(content, type = 'assistant') {
+            const message = document.createElement('div');
+            message.className = `neuroagent-message ${type}`;
+            message.textContent = content;
+            this.messagesContainer.appendChild(message);
+            this.messagesContainer.scrollTop = this.messagesContainer.scrollHeight;
+            
+            this.messages.push({ content, type });
+        }
+        
+        async sendMessage() {
+            const message = this.inputField.value.trim();
+            if (!message) return;
+            
+            this.inputField.value = '';
+            this.addMessage(message, 'user');
+            this.sendButton.disabled = true;
+            
+            this.addMessage('Thinking...', 'thinking');
+            const thinkingMsg = this.messagesContainer.lastElementChild;
+            
+            try {
+                const response = await fetch(`${this.config.apiUrl}/agent/chat`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        agent: this.config.agent,
+                        message: message
+                    })
+                });
+                
+                const data = await response.json();
+                
+                this.messagesContainer.removeChild(thinkingMsg);
+                
+                if (data.response) {
+                    this.addMessage(data.response, 'assistant');
+                } else {
+                    this.addMessage('Sorry, something went wrong.', 'assistant');
+                }
+            } catch (error) {
+                this.messagesContainer.removeChild(thinkingMsg);
+                this.addMessage('Error connecting to server.', 'assistant');
+            }
+            
+            this.sendButton.disabled = false;
+        }
+        
+        connectWebSocket() {
+            const wsUrl = this.config.wsUrl || this.config.apiUrl.replace('http', 'ws') + '/ws';
+            
+            this.websocket = new WebSocket(`${wsUrl}/${this.config.agent}`);
+            
+            this.websocket.onopen = () => {
+                console.log('NeuroAgent WebSocket connected');
+            };
+            
+            this.websocket.onmessage = (event) => {
+                const data = JSON.parse(event.data);
+                
+                if (data.type === 'response') {
+                    this.addMessage(data.message, 'assistant');
+                }
+            };
+            
+            this.websocket.onerror = (error) => {
+                console.error('WebSocket error:', error);
+            };
+        }
+        
+        async chat(message) {
+            try {
+                const response = await fetch(`${this.config.apiUrl}/agent/chat`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        agent: this.config.agent,
+                        message: message
+                    })
+                });
+                
+                const data = await response.json();
+                return data.response;
+            } catch (error) {
+                return 'Error connecting to server.';
+            }
+        }
+    }
+    
+    global.NeuroAgent = {
+        init: function(config) {
+            return new NeuroAgentWidget(config);
+        }
+    };
+    
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = global.NeuroAgent;
+    }
+    
+})(typeof window !== 'undefined' ? window : this);

package/neuroagent/llm/__init__.py

@@ -0,0 +1,5 @@
+from neuroagent.llm.base import LLMProvider, LLMResponse, Message
+from neuroagent.llm.openai_provider import OpenAIProvider
+from neuroagent.llm.local_model_provider import LocalModelProvider
+
+__all__ = ["LLMProvider", "LLMResponse", "Message", "OpenAIProvider", "LocalModelProvider"]

package/neuroagent/llm/base.py

@@ -0,0 +1,46 @@
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+
+class LLMResponse(BaseModel):
+    content: str
+    model: str
+    usage: Optional[Dict[str, int]] = None
+
+
+class LLMProvider(ABC):
+    def __init__(self, api_key: Optional[str] = None, model: str = "gpt-4"):
+        self.api_key = api_key
+        self.model = model
+    
+    @abstractmethod
+    async def chat(
+        self,
+        messages: List[Message],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        pass
+    
+    @abstractmethod
+    async def complete(
+        self,
+        prompt: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        pass
+    
+    def format_messages(self, system: str, history: List[Dict[str, str]]) -> List[Message]:
+        messages = [Message(role="system", content=system)]
+        for msg in history:
+            messages.append(Message(role=msg.get("role", "user"), content=msg.get("content", "")))
+        return messages

package/neuroagent/llm/local_model_provider.py

@@ -0,0 +1,76 @@
+import os
+import json
+import asyncio
+from typing import List, Optional, Dict, Any
+
+from neuroagent.llm.base import LLMProvider, LLMResponse, Message
+
+
+class LocalModelProvider(LLMProvider):
+    def __init__(
+        self,
+        model: str = "llama2",
+        api_base: str = "http://localhost:11434/api/generate",
+        api_key: Optional[str] = None
+    ):
+        super().__init__(api_key=api_key, model=model)
+        self.api_base = api_base
+    
+    async def _call_ollama(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        import aiohttp
+        
+        url = self.api_base
+        payload = {
+            "model": self.model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": kwargs.get("temperature", 0.7),
+                "num_predict": kwargs.get("max_tokens", 256)
+            }
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=payload) as response:
+                if response.status != 200:
+                    raise Exception(f"Ollama API error: {await response.text()}")
+                return await response.json()
+    
+    async def chat(
+        self,
+        messages: List[Message],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        system_msg = next((m.content for m in messages if m.role == "system"), "")
+        conversation = "\n".join([
+            f"{m.role}: {m.content}" 
+            for m in messages 
+            if m.role != "system"
+        ])
+        
+        prompt = f"{system_msg}\n\n{conversation}" if system_msg else conversation
+        
+        result = await self._call_ollama(
+            prompt,
+            temperature=temperature,
+            max_tokens=max_tokens or 256,
+            **kwargs
+        )
+        
+        return LLMResponse(
+            content=result.get("response", ""),
+            model=self.model,
+            usage=None
+        )
+    
+    async def complete(
+        self,
+        prompt: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        messages = [Message(role="user", content=prompt)]
+        return await self.chat(messages, temperature, max_tokens, **kwargs)

package/neuroagent/llm/openai_provider.py

@@ -0,0 +1,58 @@
+import os
+from typing import List, Optional
+from openai import AsyncOpenAI
+
+from neuroagent.llm.base import LLMProvider, LLMResponse, Message
+
+
+class OpenAIProvider(LLMProvider):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "gpt-4",
+        base_url: Optional[str] = None
+    ):
+        api_key = api_key or os.getenv("OPENAI_API_KEY")
+        super().__init__(api_key=api_key, model=model)
+        
+        self.client = AsyncOpenAI(
+            api_key=api_key,
+            base_url=base_url
+        )
+    
+    async def chat(
+        self,
+        messages: List[Message],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        openai_messages = [{"role": m.role, "content": m.content} for m in messages]
+        
+        response = await self.client.chat.completions.create(
+            model=self.model,
+            messages=openai_messages,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            **kwargs
+        )
+        
+        return LLMResponse(
+            content=response.choices[0].message.content or "",
+            model=response.model,
+            usage={
+                "prompt_tokens": response.usage.prompt_tokens if response.usage else 0,
+                "completion_tokens": response.usage.completion_tokens if response.usage else 0,
+                "total_tokens": response.usage.total_tokens if response.usage else 0
+            }
+        )
+    
+    async def complete(
+        self,
+        prompt: str,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> LLMResponse:
+        messages = [Message(role="user", content=prompt)]
+        return await self.chat(messages, temperature, max_tokens, **kwargs)

package/neuroagent/memory/__init__.py

@@ -0,0 +1,5 @@
+from neuroagent.memory.short_memory import ShortMemory
+from neuroagent.memory.long_memory import LongMemory
+from neuroagent.memory.vector_memory import VectorMemory
+
+__all__ = ["ShortMemory", "LongMemory", "VectorMemory"]

package/neuroagent/memory/long_memory.py

@@ -0,0 +1,52 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+
+class LongMemory:
+    def __init__(self, storage_path: Optional[str] = None):
+        self.storage_path = storage_path or ".neuroagent_memory.json"
+        self._memory: List[Dict[str, Any]] = self._load()
+    
+    def _load(self) -> List[Dict[str, Any]]:
+        if os.path.exists(self.storage_path):
+            try:
+                with open(self.storage_path, "r") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def _save(self):
+        with open(self.storage_path, "w") as f:
+            json.dump(self._memory, f, indent=2)
+    
+    def save(self, content: str, metadata: Optional[Dict[str, Any]] = None):
+        entry = {
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        self._memory.append(entry)
+        self._save()
+    
+    def get_all(self) -> List[Dict[str, Any]]:
+        return self._memory
+    
+    def get_by_date(self, date: str) -> List[Dict[str, Any]]:
+        return [e for e in self._memory if e["timestamp"].startswith(date)]
+    
+    def search(self, query: str) -> List[Dict[str, Any]]:
+        query_lower = query.lower()
+        return [
+            entry for entry in self._memory
+            if query_lower in entry["content"].lower()
+        ]
+    
+    def clear(self):
+        self._memory = []
+        self._save()
+    
+    def to_messages(self) -> List[Dict[str, str]]:
+        return [{"role": "system", "content": e["content"]} for e in self._memory[-10:]]

package/neuroagent/memory/short_memory.py

@@ -0,0 +1,39 @@
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from collections import deque
+
+
+class ShortMemory:
+    def __init__(self, max_items: int = 100):
+        self.max_items = max_items
+        self._memory = deque(maxlen=max_items)
+    
+    def save(self, content: str, metadata: Optional[Dict[str, Any]] = None):
+        entry = {
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        self._memory.append(entry)
+    
+    def get_recent(self, n: int = 10) -> List[Dict[str, Any]]:
+        return list(self._memory)[-n:]
+    
+    def get_all(self) -> List[Dict[str, Any]]:
+        return list(self._memory)
+    
+    def clear(self):
+        self._memory.clear()
+    
+    def search(self, query: str) -> List[Dict[str, Any]]:
+        query_lower = query.lower()
+        return [
+            entry for entry in self._memory
+            if query_lower in entry["content"].lower()
+        ]
+    
+    def to_messages(self) -> List[Dict[str, str]]:
+        return [
+            {"role": "user" if i % 2 == 0 else "assistant", "content": entry["content"]}
+            for i, entry in enumerate(self._memory)
+        ]