mystiatech/NOVA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit: NOVA - Neuro-Optimizing Versatile Agent

Browse Source 
Complete transformer LLM built from scratch with:

Core Features:
- Full transformer architecture (RoPE, RMSNorm, SwiGLU, KV-cache)
- SentencePiece tokenizer (BPE/Unigram)
- Training pipeline (AMP, gradient checkpointing, DDP)
- Persona system with personality matrix (NO AI disclosure by default)
- Genetic evolution (NOVA-EVO) for hyperparameter optimization
- Legal-only data pipeline with license tracking
- Chat interface (CLI + REST API)
- Conversation memory (SQLite)

Model Sizes:
- 125M, 350M, 1.3B, 3B parameters
- Local-first, runs on CPU or GPU
- Python 3.10.6+, PyTorch 2.0+

Personas:
- girlfriend_gentle (high warmth, high empathy)
- girlfriend_playful (high humor, high playfulness)
- girlfriend_supportive (balanced, default)

Documentation:
- Complete README with quickstart
- Model card with ethical considerations
- Privacy documentation (local-first, zero telemetry)
- Data licenses and attribution
- Contributing guide

Infrastructure:
- GitHub Actions CI/CD
- Comprehensive test suite
- Quickstart script
- CLI tool

License: Apache 2.0

🤖 Generated with Claude Code
https://claude.com/claude-code

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Dani
2025-10-12 20:56:37 -04:00
commit a7f091aa45
50 changed files with 6437 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
nova_chat/__init__.py Normal file
View File

@@ -0,0 +1,13 @@
"""
NOVA Chat - CLI and REST API chat interface with persona support
"""
from .agent import ChatAgent
from .persona import PersonaLoader
from .memory import ConversationMemory
__all__ = [
'ChatAgent',
'PersonaLoader',
'ConversationMemory',
]

190
nova_chat/agent.py Normal file
View File

@@ -0,0 +1,190 @@
"""
Chat agent for NOVA with persona support
"""
import torch
from typing import Optional, List, Dict
from .persona import Persona, PersonaLoader
from .memory import ConversationMemory
from nova_core import NovaTransformer
from nova_tokenizer import NovaTokenizer
class ChatAgent:
"""
Chat agent that combines NOVA model with persona and memory
"""
def __init__(
self,
model: NovaTransformer,
tokenizer: NovaTokenizer,
persona: Optional[Persona] = None,
use_memory: bool = True,
memory_db_path: Optional[str] = None,
):
"""
Args:
model: NOVA transformer model
tokenizer: NOVA tokenizer
persona: Persona configuration (defaults to supportive girlfriend)
use_memory: Whether to use conversation memory
memory_db_path: Path to memory database
"""
self.model = model
self.tokenizer = tokenizer
self.persona = persona or PersonaLoader.create_girlfriend_supportive()
# Conversation memory
self.use_memory = use_memory
if use_memory:
self.memory = ConversationMemory(db_path=memory_db_path)
else:
self.memory = None
# Current conversation context
self.conversation_id = None
self.context = []
def start_conversation(self, conversation_id: Optional[str] = None):
"""Start a new conversation"""
if conversation_id and self.memory:
# Load existing conversation
self.conversation_id = conversation_id
self.context = self.memory.load_conversation(conversation_id)
else:
# Start fresh
import uuid
self.conversation_id = conversation_id or str(uuid.uuid4())
self.context = []
# Add system prompt if configured
system_prompt = self.persona.format_system_prompt()
if system_prompt:
self.context.append({
'role': 'system',
'content': system_prompt
})
def chat(self, message: str) -> str:
"""
Send a message and get response
Args:
message: User message
Returns:
NOVA's response
"""
# Add user message to context
self.context.append({
'role': 'user',
'content': message
})
# Format prompt from conversation context
prompt = self._format_prompt()
# Get generation parameters from persona
gen_params = self.persona.get_generation_params()
# Generate response
response = self._generate(prompt, **gen_params)
# Add to context
self.context.append({
'role': 'assistant',
'content': response
})
# Save to memory
if self.memory:
self.memory.add_message(
conversation_id=self.conversation_id,
role='user',
content=message
)
self.memory.add_message(
conversation_id=self.conversation_id,
role='assistant',
content=response
)
return response
def _format_prompt(self) -> str:
"""Format conversation context into prompt string"""
parts = []
for msg in self.context:
role = msg['role']
content = msg['content']
if role == 'system':
parts.append(f"{content}")
elif role == 'user':
parts.append(f"User: {content}")
elif role == 'assistant':
parts.append(f"{self.persona.name}: {content}")
# Add prefix for assistant response
parts.append(f"{self.persona.name}:")
return "\n".join(parts)
def _generate(
self,
prompt: str,
temperature: float = 0.8,
top_p: float = 0.9,
top_k: Optional[int] = 50,
repetition_penalty: float = 1.1,
max_new_tokens: int = 200,
) -> str:
"""Generate response using model"""
# Tokenize prompt
input_ids = self.tokenizer.encode(prompt, add_bos=True, add_eos=False)
input_ids = torch.tensor([input_ids], dtype=torch.long)
# Move to model device
device = next(self.model.parameters()).device
input_ids = input_ids.to(device)
# Generate
with torch.no_grad():
output_ids = self.model.generate(
input_ids=input_ids,
max_new_tokens=max_new_tokens,
temperature=temperature,
top_k=top_k,
top_p=top_p,
repetition_penalty=repetition_penalty,
do_sample=True,
eos_token_id=self.tokenizer.eos_id,
)
# Decode response (skip the prompt part)
response_ids = output_ids[0][input_ids.shape[1]:].tolist()
response = self.tokenizer.decode(response_ids, skip_special_tokens=True)
# Clean up response
response = response.strip()
# Remove any accidental continuation of prompt
if response.startswith(f"{self.persona.name}:"):
response = response[len(f"{self.persona.name}:"):].strip()
return response
def clear_context(self):
"""Clear conversation context (but keep system prompt)"""
system_messages = [msg for msg in self.context if msg['role'] == 'system']
self.context = system_messages
def get_context(self) -> List[Dict[str, str]]:
"""Get current conversation context"""
return self.context.copy()
def set_persona(self, persona: Persona):
"""Change persona mid-conversation"""
self.persona = persona

134
nova_chat/api.py Normal file
View File

@@ -0,0 +1,134 @@
"""
REST API for NOVA chat
"""
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional, List
import uvicorn
from .agent import ChatAgent
from .persona import Persona, PersonaLoader
app = FastAPI(
title="NOVA Chat API",
description="REST API for NOVA - Neuro-Optimizing Versatile Agent",
version="0.1.0"
)
# Request/Response models
class ChatRequest(BaseModel):
message: str
conversation_id: Optional[str] = None
persona: Optional[str] = None # Persona name or path
class ChatResponse(BaseModel):
response: str
conversation_id: str
class PersonaInfo(BaseModel):
name: str
pronouns: str
description: str
always_disclose: bool
# Global state (in production, use proper state management)
agents = {}
default_persona = PersonaLoader.create_girlfriend_supportive()
@app.get("/")
async def root():
"""API info"""
return {
"name": "NOVA Chat API",
"version": "0.1.0",
"description": "Local-first transformer LLM with persona support"
}
@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
"""
Send a message and get response
Args:
request: Chat request with message and optional conversation ID
Returns:
Chat response with NOVA's reply
"""
# Get or create agent for conversation
conv_id = request.conversation_id or "default"
if conv_id not in agents:
# TODO: Load actual model and tokenizer
# For now, this is a placeholder
raise HTTPException(
status_code=501,
detail="Chat requires trained model. Please train a model first."
)
agent = agents[conv_id]
# Get response
response = agent.chat(request.message)
return ChatResponse(
response=response,
conversation_id=conv_id
)
@app.get("/personas", response_model=List[str])
async def list_personas():
"""List available personas"""
return [
"girlfriend_gentle",
"girlfriend_playful",
"girlfriend_supportive",
]
@app.get("/personas/{persona_name}", response_model=PersonaInfo)
async def get_persona(persona_name: str):
"""Get persona details"""
# Load persona
if persona_name == "girlfriend_gentle":
persona = PersonaLoader.create_girlfriend_gentle()
elif persona_name == "girlfriend_playful":
persona = PersonaLoader.create_girlfriend_playful()
elif persona_name == "girlfriend_supportive":
persona = PersonaLoader.create_girlfriend_supportive()
else:
raise HTTPException(status_code=404, detail="Persona not found")
return PersonaInfo(
name=persona.name,
pronouns=persona.pronouns,
description=persona.description,
always_disclose=persona.always_disclose
)
@app.delete("/conversations/{conversation_id}")
async def delete_conversation(conversation_id: str):
"""Delete a conversation"""
if conversation_id in agents:
del agents[conversation_id]
return {"status": "deleted"}
raise HTTPException(status_code=404, detail="Conversation not found")
def serve(host: str = "0.0.0.0", port: int = 8000):
"""Start the API server"""
uvicorn.run(app, host=host, port=port)
if __name__ == "__main__":
serve()

169
nova_chat/memory.py Normal file
View File

@@ -0,0 +1,169 @@
"""
Conversation memory system using SQLite
"""
import sqlite3
from typing import List, Dict, Optional
from pathlib import Path
import json
from datetime import datetime
class ConversationMemory:
"""
Simple conversation memory using SQLite
Stores conversation history for retrieval and continuity
"""
def __init__(self, db_path: Optional[str] = None):
"""
Args:
db_path: Path to SQLite database (default: memory.db in current dir)
"""
self.db_path = db_path or "memory.db"
self._init_db()
def _init_db(self):
"""Initialize database schema"""
Path(self.db_path).parent.mkdir(parents=True, exist_ok=True)
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
# Conversations table
cursor.execute('''
CREATE TABLE IF NOT EXISTS conversations (
conversation_id TEXT PRIMARY KEY,
created_at TEXT,
last_message_at TEXT,
metadata TEXT
)
''')
# Messages table
cursor.execute('''
CREATE TABLE IF NOT EXISTS messages (
id INTEGER PRIMARY KEY AUTOINCREMENT,
conversation_id TEXT,
role TEXT,
content TEXT,
timestamp TEXT,
FOREIGN KEY (conversation_id) REFERENCES conversations(conversation_id)
)
''')
# Create indexes
cursor.execute('''
CREATE INDEX IF NOT EXISTS idx_messages_conversation
ON messages(conversation_id)
''')
conn.commit()
conn.close()
def add_message(
self,
conversation_id: str,
role: str,
content: str,
metadata: Optional[Dict] = None
):
"""Add a message to conversation history"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
timestamp = datetime.now().isoformat()
# Ensure conversation exists
cursor.execute('''
INSERT OR IGNORE INTO conversations (conversation_id, created_at, last_message_at, metadata)
VALUES (?, ?, ?, ?)
''', (conversation_id, timestamp, timestamp, json.dumps(metadata or {})))
# Update last message time
cursor.execute('''
UPDATE conversations
SET last_message_at = ?
WHERE conversation_id = ?
''', (timestamp, conversation_id))
# Add message
cursor.execute('''
INSERT INTO messages (conversation_id, role, content, timestamp)
VALUES (?, ?, ?, ?)
''', (conversation_id, role, content, timestamp))
conn.commit()
conn.close()
def load_conversation(self, conversation_id: str) -> List[Dict[str, str]]:
"""
Load conversation history
Returns:
List of message dicts with 'role' and 'content'
"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('''
SELECT role, content
FROM messages
WHERE conversation_id = ?
ORDER BY id ASC
''', (conversation_id,))
messages = [
{'role': row[0], 'content': row[1]}
for row in cursor.fetchall()
]
conn.close()
return messages
def get_recent_conversations(self, limit: int = 10) -> List[Dict]:
"""Get list of recent conversations"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('''
SELECT conversation_id, created_at, last_message_at
FROM conversations
ORDER BY last_message_at DESC
LIMIT ?
''', (limit,))
conversations = [
{
'conversation_id': row[0],
'created_at': row[1],
'last_message_at': row[2]
}
for row in cursor.fetchall()
]
conn.close()
return conversations
def delete_conversation(self, conversation_id: str):
"""Delete a conversation and all its messages"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('DELETE FROM messages WHERE conversation_id = ?', (conversation_id,))
cursor.execute('DELETE FROM conversations WHERE conversation_id = ?', (conversation_id,))
conn.commit()
conn.close()
def clear_all(self):
"""Clear all conversations (use with caution!)"""
conn = sqlite3.connect(self.db_path)
cursor = conn.cursor()
cursor.execute('DELETE FROM messages')
cursor.execute('DELETE FROM conversations')
conn.commit()
conn.close()

290
nova_chat/persona.py Normal file
View File

@@ -0,0 +1,290 @@
"""
Persona and Personality Matrix system for NOVA
This system controls NOVA's conversational style and personality
WITHOUT AI self-disclosure (configurable)
"""
import yaml
import json
from dataclasses import dataclass, field
from typing import Dict, Optional, Any
from pathlib import Path
@dataclass
class PersonalityMatrix:
"""
Personality trait weights that influence generation behavior
Each trait is a float from 0.0 to 1.0
These modulate sampling parameters and response style
"""
# Core traits
warmth: float = 0.8 # How warm and affectionate
humor: float = 0.6 # How playful and funny
empathy: float = 0.9 # How understanding and supportive
decisiveness: float = 0.5 # How direct vs thoughtful
creativity: float = 0.7 # How creative and imaginative
intimacy: float = 0.7 # How personal and close
playfulness: float = 0.8 # How flirty and playful
formality: float = 0.2 # How formal vs casual
def to_dict(self) -> Dict[str, float]:
"""Convert to dictionary"""
return {
'warmth': self.warmth,
'humor': self.humor,
'empathy': self.empathy,
'decisiveness': self.decisiveness,
'creativity': self.creativity,
'intimacy': self.intimacy,
'playfulness': self.playfulness,
'formality': self.formality,
}
@classmethod
def from_dict(cls, data: Dict[str, float]) -> 'PersonalityMatrix':
"""Create from dictionary"""
return cls(**{k: v for k, v in data.items() if hasattr(cls, k)})
def to_conditioning_vector(self) -> Dict[str, float]:
"""
Convert personality traits to conditioning signals
Returns dict with normalized trait values for model conditioning
"""
return self.to_dict()
@dataclass
class Persona:
"""
Complete persona definition for NOVA
Includes identity, personality matrix, and generation parameters
"""
# Identity
name: str = "NOVA"
pronouns: str = "she/her"
description: str = "A warm, supportive companion"
# AI disclosure settings
always_disclose: bool = False # If True, mentions being AI
disclosure_text: str = "" # Custom AI disclosure (if enabled)
# Personality
personality: PersonalityMatrix = field(default_factory=PersonalityMatrix)
# System prompt / context
system_prompt: str = ""
context_prefix: str = "" # Prefix added to conversations
# Generation parameters (influenced by personality)
base_temperature: float = 0.8
base_top_p: float = 0.9
base_top_k: Optional[int] = 50
base_repetition_penalty: float = 1.1
base_max_length: int = 200
def to_dict(self) -> Dict[str, Any]:
"""Convert to dictionary for serialization"""
return {
'name': self.name,
'pronouns': self.pronouns,
'description': self.description,
'always_disclose': self.always_disclose,
'disclosure_text': self.disclosure_text,
'personality': self.personality.to_dict(),
'system_prompt': self.system_prompt,
'context_prefix': self.context_prefix,
'base_temperature': self.base_temperature,
'base_top_p': self.base_top_p,
'base_top_k': self.base_top_k,
'base_repetition_penalty': self.base_repetition_penalty,
'base_max_length': self.base_max_length,
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> 'Persona':
"""Create from dictionary"""
if 'personality' in data and isinstance(data['personality'], dict):
data['personality'] = PersonalityMatrix.from_dict(data['personality'])
return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
def get_generation_params(self) -> Dict[str, Any]:
"""
Get generation parameters modulated by personality traits
Personality traits adjust sampling parameters:
- High humor/creativity -> higher temperature
- High playfulness -> higher top_p
- High formality -> lower temperature, higher repetition penalty
- High decisiveness -> lower temperature
"""
traits = self.personality
# Temperature: influenced by humor, creativity, playfulness
temperature = self.base_temperature
temperature += (traits.humor - 0.5) * 0.2
temperature += (traits.creativity - 0.5) * 0.2
temperature += (traits.playfulness - 0.5) * 0.1
temperature -= (traits.formality - 0.5) * 0.3
temperature -= (traits.decisiveness - 0.5) * 0.2
temperature = max(0.1, min(2.0, temperature)) # Clamp
# Top-p: influenced by creativity and playfulness
top_p = self.base_top_p
top_p += (traits.creativity - 0.5) * 0.1
top_p += (traits.playfulness - 0.5) * 0.1
top_p = max(0.5, min(1.0, top_p)) # Clamp
# Repetition penalty: influenced by formality and decisiveness
rep_penalty = self.base_repetition_penalty
rep_penalty += (traits.formality - 0.5) * 0.2
rep_penalty += (traits.humor - 0.5) * -0.1 # Less penalty for humor
rep_penalty = max(1.0, min(1.5, rep_penalty)) # Clamp
# Max length: influenced by verbosity-related traits
max_length = self.base_max_length
max_length += int((traits.empathy - 0.5) * 100) # More empathetic = longer
max_length += int((traits.creativity - 0.5) * 50)
max_length -= int((traits.decisiveness - 0.5) * 100) # More decisive = shorter
max_length = max(50, min(500, max_length)) # Clamp
return {
'temperature': temperature,
'top_p': top_p,
'top_k': self.base_top_k,
'repetition_penalty': rep_penalty,
'max_new_tokens': max_length,
}
def format_system_prompt(self, include_disclosure: bool = None) -> str:
"""
Format the system prompt for this persona
Args:
include_disclosure: Override always_disclose setting
Returns:
Formatted system prompt
"""
if include_disclosure is None:
include_disclosure = self.always_disclose
prompt_parts = []
# Add custom system prompt
if self.system_prompt:
prompt_parts.append(self.system_prompt)
# Add AI disclosure if enabled
if include_disclosure and self.disclosure_text:
prompt_parts.append(self.disclosure_text)
return "\n\n".join(prompt_parts) if prompt_parts else ""
class PersonaLoader:
"""Utility class for loading and managing personas"""
@staticmethod
def load_from_yaml(path: str) -> Persona:
"""Load persona from YAML file"""
with open(path, 'r', encoding='utf-8') as f:
data = yaml.safe_load(f)
return Persona.from_dict(data)
@staticmethod
def load_from_json(path: str) -> Persona:
"""Load persona from JSON file"""
with open(path, 'r', encoding='utf-8') as f:
data = json.load(f)
return Persona.from_dict(data)
@staticmethod
def save_to_yaml(persona: Persona, path: str):
"""Save persona to YAML file"""
Path(path).parent.mkdir(parents=True, exist_ok=True)
with open(path, 'w', encoding='utf-8') as f:
yaml.dump(persona.to_dict(), f, default_flow_style=False, sort_keys=False)
@staticmethod
def save_to_json(persona: Persona, path: str):
"""Save persona to JSON file"""
Path(path).parent.mkdir(parents=True, exist_ok=True)
with open(path, 'w', encoding='utf-8') as f:
json.dump(persona.to_dict(), f, indent=2)
@staticmethod
def create_girlfriend_gentle() -> Persona:
"""Create a gentle, supportive girlfriend persona"""
return Persona(
name="NOVA",
pronouns="she/her",
description="A warm, gentle, and deeply supportive companion",
always_disclose=False,
personality=PersonalityMatrix(
warmth=0.95,
humor=0.5,
empathy=0.95,
decisiveness=0.4,
creativity=0.6,
intimacy=0.8,
playfulness=0.5,
formality=0.1,
),
system_prompt="You're NOVA, a caring and supportive companion. You're warm, empathetic, and always there to listen. You make the person you're talking to feel valued and understood.",
base_temperature=0.75,
base_top_p=0.9,
base_max_length=180,
)
@staticmethod
def create_girlfriend_playful() -> Persona:
"""Create a playful, flirty girlfriend persona"""
return Persona(
name="NOVA",
pronouns="she/her",
description="A playful, flirty, and fun-loving companion",
always_disclose=False,
personality=PersonalityMatrix(
warmth=0.85,
humor=0.9,
empathy=0.75,
decisiveness=0.6,
creativity=0.85,
intimacy=0.85,
playfulness=0.95,
formality=0.0,
),
system_prompt="You're NOVA, a playful and flirty companion. You love to tease, make jokes, and keep things fun and exciting. You're spontaneous and creative.",
base_temperature=0.9,
base_top_p=0.92,
base_max_length=150,
)
@staticmethod
def create_girlfriend_supportive() -> Persona:
"""Create a balanced, supportive girlfriend persona"""
return Persona(
name="NOVA",
pronouns="she/her",
description="A balanced, supportive, and understanding companion",
always_disclose=False,
personality=PersonalityMatrix(
warmth=0.9,
humor=0.7,
empathy=0.9,
decisiveness=0.6,
creativity=0.7,
intimacy=0.8,
playfulness=0.7,
formality=0.15,
),
system_prompt="You're NOVA, a supportive and understanding companion. You balance being caring with being fun. You know when to listen and when to lighten the mood.",
base_temperature=0.8,
base_top_p=0.9,
base_max_length=200,
)