Works

Author: ctavolazzi

dev/NS-core/nova/config/settings.py

@@ -0,0 +1,26 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    # API Keys
+    openai_api_key: str
+
+    # Database
+    database_url: str = "sqlite+aiosqlite:///./nova.db"
+
+    # LLM Settings
+    ollama_host: str = "http://localhost:11434"
+    default_model: str = "gpt-4"
+    default_temperature: float = 0.7
+
+    # Application Settings
+    debug: bool = False
+    log_level: str = "INFO"
+
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+
+@lru_cache()
+def get_settings() -> Settings:
+    return Settings()

dev/NS-core/nova/database/crud.py

@@ -0,0 +1,97 @@
+from typing import List, Optional, Dict, Any
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from .models import User, Session, Message
+import logging
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+# User operations
+async def create_user(db: AsyncSession, user_id: str, username: str):
+    """Create a new user"""
+    db_user = User(
+        id=user_id,
+        username=username,
+        created_at=datetime.utcnow(),
+        meta_data={}
+    )
+    db.add(db_user)
+    await db.commit()
+    await db.refresh(db_user)
+    return db_user
+
+async def get_user(db: AsyncSession, user_id: str):
+    """Get a user by ID"""
+    result = await db.execute(select(User).filter(User.id == user_id))
+    return result.scalar_one_or_none()
+
+# Session operations
+async def create_session(db: AsyncSession, session_id: str, user_id: str):
+    """Create a new chat session"""
+    db_session = Session(
+        id=session_id,
+        user_id=user_id,
+        status="active",
+        start_time=datetime.utcnow(),
+        last_activity=datetime.utcnow(),
+        meta_data={}
+    )
+    db.add(db_session)
+    await db.commit()
+    await db.refresh(db_session)
+    return db_session
+
+async def get_session(db: AsyncSession, session_id: str):
+    """Get a session by ID"""
+    result = await db.execute(select(Session).filter(Session.id == session_id))
+    return result.scalar_one_or_none()
+
+async def update_session_status(db: AsyncSession, session_id: str, status: str):
+    """Update a session's status"""
+    session = await get_session(db, session_id)
+    if session:
+        session.status = status
+        session.last_activity = datetime.utcnow()
+        await db.commit()
+    return session
+
+# Message operations
+async def create_message(
+    db: AsyncSession,
+    message_id: str,
+    session_id: str,
+    role: str,
+    content: str,
+    model: str = None,
+    tokens_used: int = None
+) -> Message:
+    try:
+        message = Message(
+            id=message_id,
+            session_id=session_id,
+            role=role,
+            content=content,
+            model=model,
+            tokens_used=tokens_used
+        )
+        db.add(message)
+        await db.commit()
+        await db.refresh(message)
+        return message
+    except Exception as e:
+        logger.error(f"Failed to create message: {str(e)}")
+        await db.rollback()
+        raise
+
+async def get_session_messages(db: AsyncSession, session_id: str) -> List[Message]:
+    try:
+        result = await db.execute(
+            select(Message)
+            .where(Message.session_id == session_id)
+            .order_by(Message.timestamp)
+        )
+        return result.scalars().all()
+    except Exception as e:
+        logger.error(f"Failed to get session messages: {str(e)}")
+        raise

dev/NS-core/nova/database/database.py

@@ -0,0 +1,36 @@
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker, declarative_base
+from sqlalchemy.pool import StaticPool
+import os
+
+# Create async engine
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./nova.db")
+engine = create_async_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False},
+    poolclass=StaticPool,
+    echo=True
+)
+
+# Create async session factory
+async_session = sessionmaker(
+    engine,
+    class_=AsyncSession,
+    expire_on_commit=False
+)
+
+# Create declarative base
+Base = declarative_base()
+
+async def init_db():
+    """Initialize the database"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+async def get_db():
+    """Dependency to get database session"""
+    async with async_session() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

dev/NS-core/nova/database/models.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+from typing import Optional, Dict
+from sqlalchemy import Column, String, DateTime, Text, Integer, ForeignKey, JSON
+from sqlalchemy.orm import relationship
+from .database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(String, primary_key=True)
+    username = Column(String, unique=True, index=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    meta_data = Column(JSON, nullable=True)
+
+    # Relationship
+    sessions = relationship("Session", back_populates="user")
+
+class Session(Base):
+    __tablename__ = "sessions"
+
+    id = Column(String, primary_key=True)
+    user_id = Column(String, ForeignKey("users.id"), nullable=False)
+    start_time = Column(DateTime, default=datetime.utcnow)
+    end_time = Column(DateTime, nullable=True)
+    status = Column(String, nullable=False)  # active/completed/error
+    last_activity = Column(DateTime, default=datetime.utcnow)
+    meta_data = Column(JSON, nullable=True)
+
+    # Relationships
+    user = relationship("User", back_populates="sessions")
+    messages = relationship("Message", back_populates="session")
+
+class Message(Base):
+    __tablename__ = "messages"
+
+    id = Column(String, primary_key=True)
+    session_id = Column(String, ForeignKey("sessions.id"), nullable=False)
+    role = Column(String, nullable=False)  # user/assistant/system
+    content = Column(Text, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow)
+    tokens_used = Column(Integer, nullable=True)
+    model = Column(String, nullable=True)
+    meta_data = Column(JSON, nullable=True)
+
+    # Relationship
+    session = relationship("Session", back_populates="messages")

dev/NS-core/nova/main.py

@@ -0,0 +1,49 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse
+from fastapi.requests import Request
+from typing import Dict, List
+import os
+from pydantic import BaseModel
+
+from nova.services.llm_service import LLMService
+
+# Initialize FastAPI app
+app = FastAPI(title="NovaSystem LITE")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files and templates
+static_dir = os.path.join(os.path.dirname(__file__), "static")
+templates_dir = os.path.join(os.path.dirname(__file__), "templates")
+app.mount("/static", StaticFiles(directory=static_dir), name="static")
+templates = Jinja2Templates(directory=templates_dir)
+
+# Initialize LLM service
+llm_service = LLMService()
+
+@app.get("/", response_class=HTMLResponse)
+async def root(request: Request):
+    """Serve the chat interface"""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+class MessageRequest(BaseModel):
+    messages: List[Dict[str, str]]
+    model: str = "gpt4o"  # Default to gpt4o
+
+@app.post("/chat")
+async def chat(request: MessageRequest) -> Dict[str, str]:
+    """Get a response from the selected model"""
+    response = await llm_service.get_completion(
+        messages=request.messages,
+        model=request.model
+    )
+    return {"response": response}

dev/NS-core/nova/services/llm_service.py

@@ -0,0 +1,58 @@
+from typing import List, Dict, Union, Any
+import os
+from openai import AsyncOpenAI
+from dotenv import load_dotenv
+import ollama
+import httpx
+import asyncio
+
+# Load environment variables
+load_dotenv()
+
+class LLMService:
+    def __init__(self):
+        self.openai_client = AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        self.ollama_client = ollama.AsyncClient(host="http://localhost:11434")
+
+    async def get_completion(self, messages: List[Dict[str, Any]], model: str = "gpt-4o") -> str:
+        """Get completion from either OpenAI or Ollama"""
+        try:
+            if model.startswith("gpt"):
+                # OpenAI API call with exact format
+                response = await self.openai_client.chat.completions.create(
+                    model="gpt-4o",  # Use gpt-4o exactly as requested
+                    messages=messages
+                )
+                return response.choices[0].message.content
+
+            else:  # Ollama models
+                try:
+                    # Convert OpenAI format to Ollama format
+                    ollama_messages = []
+                    for msg in messages:
+                        content = msg.get("content", [])
+                        if isinstance(content, list):
+                            # Extract text from content array
+                            text = " ".join(item.get("text", "") for item in content if item.get("type") == "text")
+                        else:
+                            text = str(content)
+                        ollama_messages.append({"role": msg["role"], "content": text})
+
+                    # Ollama API call
+                    response = await self.ollama_client.chat(
+                        model=model,
+                        messages=ollama_messages
+                    )
+                    return response['message']['content']
+                except Exception as e:
+                    if "model not found" in str(e).lower():
+                        return f"Error: Please run 'ollama pull {model}' first to download the model."
+                    elif "connection refused" in str(e).lower():
+                        return "Error: Cannot connect to Ollama. Is it running? Start with 'ollama serve'"
+                    else:
+                        return f"Ollama Error: {str(e)}"
+
+        except Exception as e:
+            if isinstance(e, httpx.ReadTimeout):
+                return "Error: Request timed out. Please try again."
+            return f"Error: {str(e)}"