Azari

Azari is a local-first desktop AI assistant, research partner, and engineering-support system for conversation, project reasoning, memory, and tool-backed workflows.

It is designed to feel like one coherent app: you can chat with it, ask it to explain things, continue a project thread, inspect saved conversations, use local memory, and route into supported tools without leaving the desktop shell.

Azari is not presented as a frontier model trained from scratch. Its strength comes from a local orchestration stack: intent detection, routing, curated local knowledge, bounded memory, reasoning support, tool manifests, SQLite persistence, and validation surfaces that make its limits visible.

Current Status

This repository is the Azari v2 source release line. The source is published on GitHub at aleksandermagi-dev/Azari.AIv2, tagged as v2.0.0, and marked functionally complete from the latest local validation pass.

The latest packaged target is:

dist/Azari.exe

Current release status is tracked in AZARI_V2_RELEASE_STATUS.md.

The app currently supports:

• A Windows desktop chat shell.
• Local-first conversation and reasoning.
• One collaborative base voice with compatible response style preferences for collab, default, and direct.
• Saved sessions, all conversations, archived chats, memory, archived memory, and settings.
• Local SQLite-backed persistence.
• Curated local knowledge and broad-topic answering where coverage exists.
• Research/tool routing for supported bundles.
• ANH spectral-analysis support when the runtime bundle and dependencies are available.
• Offline validation, decision evaluation, and scripted long-conversation QA foundations.

What Azari Does

Azari can help with ordinary conversation, explanations, planning, research support, and local tool workflows.

Core user-facing capabilities include:

• Conversational chat that can handle greetings, follow-ups, self-questions, pivots, and longer back-and-forth sessions.
• General explanations across covered local knowledge domains such as astronomy, physics, chemistry, biology, earth science, engineering, history, math, science, and computing.
• Project-aware continuity when there is an active thread or recent project context.
• Local memory use that is intentionally bounded so old memories do not flood ordinary chat.
• Saved conversation restore, archive browsing, memory browsing, and settings persistence.
• Tool routing for supported local capabilities such as bounded symbolic math, data, knowledge graph operations, paper workflows, simulation, visualization, system inspection, and ANH.
• Offline evaluation of persisted interactions and scripted long-conversation behavior.

Azari is built to answer when it has enough local support and to say when it does not.

How Azari Works

Azari routes each turn through a local pipeline:

1. User input enters through the desktop app or CLI.
2. NLU and routing classify the request as conversation, knowledge, research, planning, memory, or tool intent.
3. Context assembly selects a bounded set of recent turns, active-thread state, project context, local knowledge, and relevant memory.
4. The reasoning and response layers choose the answer shape, confidence posture, and whether a tool should be used.
5. The final wording layer applies adaptive response depth, format, and tone nuance without changing the underlying route, reasoning authority, safety posture, tool access, or knowledge access.
6. Persistence saves messages, sessions, interactions, memory records, tool runs, and diagnostics locally.

The goal is not to make every prompt use every subsystem. The goal is to choose the smallest useful path for the turn.

Desktop App

The desktop app is the main Azari experience.

It includes:

• Chat with visible thinking/responding state.
• Response style selection with collaborative/base, balanced, and concise preferences.
• Saved conversations and archived conversations.
• Memory and archived memory views.
• Popup-first settings.
• Theme and profile persistence.
• Attachment handoff for files, folders, and zip inputs.
• Lazy loading for heavier views so the shell does not eagerly load everything at startup.

In source mode, local app data defaults to the repository data/ directory. In packaged Windows mode, writable desktop data defaults to:

%LOCALAPPDATA%/Azari/data

The packaged app separates read-only runtime resources from writable user data.

Conversation, Response Style, and Long-Chat Behavior

Azari's default identity is a collaborative thinking partner. Older collab, default, and direct values are still accepted for saved profiles and settings, but they now act as response style preferences rather than separate personalities:

• collab: the natural base collaborative voice.
• default: normal depth, conversational format, balanced calm/guiding wording.
• direct: short depth, conversational format, precise wording.

Response style affects final wording and packaging only. It does not make Azari smarter or weaker, and it must not change route authority, knowledge access, safety boundaries, memory authority, tool access, or reasoning authority.

Recent conversation work focuses on:

• Keeping casual chat conversational instead of over-triggering research.
• Handling self-referential prompts such as "who are you" or "what about you" conversationally.
• Reducing repeated closers and canned follow-up offers over longer chats.
• Anchoring "what next", "keep going", "summarize where we are", and similar prompts to the active work thread when one exists.
• Keeping memory helpful without over-injecting old personal details.

Memory and Local Persistence

Azari is local-first by default.

Structured runtime state is stored in SQLite and local files under the active data root. In source mode that is normally:

data/
data/persistence/azari.sqlite3

The persistence layer stores and indexes things such as:

• Sessions and messages.
• Interaction records.
• Session summaries.
• Memory items.
• Research notes and artifacts.
• Tool runs.
• Preferences and settings.
• Knowledge entries and aliases.
• Dataset curation records.

Memory is selective. Azari does not blindly inject every old note into chat. Personal memory is used most strongly when the user asks for recall or when the current turn clearly benefits from it.

Knowledge, Research, and Tools

Azari has a local knowledge surface for covered topics and a tool-routing surface for supported workflows.

The current registry includes bundles such as:

• anh
• astronomy
• content
• data
• design
• experiment
• invent
• knowledge
• math
• memory
• paper
• physics
• report
• simulate
• system
• viz
• workspace

Examples of supported capability areas include:

• Bounded symbolic math for common single-variable equations, plus symbolic/numerical helpers.
• Data description, correlation, regression, clustering, and visualization.
• Knowledge graph linking, paths, clustering, and contradiction checks.
• Paper search, summary, comparison, and method extraction.
• Simulation helpers for systems, orbits, populations, and diffusion.
• Visualization helpers for graphs, networks, timelines, and parameter spaces.
• Workspace inspection and system analysis.

Some capabilities are provider-gated or runtime-gated. Azari should report those limits instead of pretending a missing provider or missing resource exists.

ANH Capability

ANH is Azari's astronomy-oriented spectral dip scan workflow.

In the current validated packaged runtime, ANH can analyze supplied FITS spectra when the required runtime resources and dependencies are present. It can report candidate spectral dips, including candidate velocity/depth information, and it is treated as a tool-backed analysis path rather than a generic chat answer.

The intended distinction is:

• "What is ANH?" should answer from local knowledge.
• "Run ANH on this FITS file" should route to the ANH tool path.

Datasets and Evaluation

Azari includes local evaluation and dataset-curation foundations.

It can:

• Evaluate persisted interactions offline.
• Review routing, memory relevance, tool-use decisions, confidence calibration, and response behavior.
• Export labeled examples for downstream review.
• Import JSON, JSONL, and mapped CSV datasets into SQLite.
• Track dataset batches, versions, splits, labels, corrections, and provenance.
• Run scripted long-conversation evaluation for local QA.

This does not mean Azari trains a model by itself. Dataset support is for local curation, review, export, and evaluation workflows.

Safety and Limits

Azari is designed to be honest about capability boundaries.

It does not claim to provide:

• Medical diagnosis or treatment guidance.
• Legal, financial, or investment authority.
• Live news authority without a configured live source.
• Universal web research.
• Autonomous unrestricted automation.
• Fabrication-grade engineering signoff.
• Complete academic ghostwriting.
• Exhaustive local knowledge of every topic.
• A full computer algebra system for every mathematical form.

For unsupported or weakly grounded prompts, the desired behavior is to say that it does not have enough local knowledge or runtime support.

What Azari Is Not

Azari is not:

• A cloud-hosted frontier model.
• A massive LLM trained from scratch.
• A replacement for professional judgment.
• A universal live-web agent.
• An autonomous ML training platform.
• A hidden black box with no local persistence trail.

It is a local desktop AI system that combines conversation, reasoning, memory, curated knowledge, tools, and validation into one app.

Run Azari

Install for development:

python -m pip install -e .[dev]

Launch the desktop app from source:

azari-desktop

Run the packaged Windows app:

dist/Azari.exe

The executable is built locally and intentionally not committed to the repository. A public binary release asset is deferred until final binary/data hygiene is checked.

Build The Windows Executable

Azari uses PyInstaller and the checked-in main.spec file to build the desktop executable.

From a fresh checkout:

python -m venv .venv
.\.venv\Scripts\python.exe -m pip install --upgrade pip
.\.venv\Scripts\python.exe -m pip install -e .[dev]
.\.venv\Scripts\python.exe -m PyInstaller main.spec

The rebuilt executable is written to:

dist/Azari.exe

Before distributing a rebuilt executable, run at least a focused validation pass:

.\.venv\Scripts\python.exe -m pytest tests\unit\test_interaction_service.py tests\unit\test_chat_ui_support.py tests\unit\test_persistence_manager.py -q
.\.venv\Scripts\python.exe -m azari.validation.system_sweep --mode fast --force-fresh-packaged --packaged-executable dist\Azari.exe

For a final release-candidate gate, run the full sweep and include the selected ANH MAST probe when available:

.\.venv\Scripts\python.exe -m azari.validation.system_sweep --mode full --force-fresh-packaged --packaged-executable dist\Azari.exe --anh-probe "MAST file\MAST_2025-08-20T21_51_26.049Z.zip"

The dist/, build/, local data/, debug logs, and MAST files are intentionally ignored by Git. They are local build/runtime artifacts, not source files.

Initialize a workspace:

azari init
python -m azari init

Check local readiness:

azari doctor
python -m azari --format text doctor

Ask from the CLI:

azari ask "hello"
azari ask "tell me about space"
azari ask "compare black holes and neutron stars"
azari ask "solve 2x + 5 = 13"

Start the CLI REPL:

azari
azari repl

Useful CLI Commands

Inspect bundles and capabilities:

azari list-tools
azari list-capabilities
azari bundle inspect anh
azari bundle inspect data
azari bundle inspect knowledge

Inspect sessions, interactions, and persistence:

azari interaction list
azari interaction summary
azari interaction evaluate
azari persistence status
azari persistence doctor
azari session current default
azari session inspect default

Inspect memory and research artifacts:

azari memory notes
azari memory artifacts

Curate and export datasets:

azari dataset derive-runtime-dataset azari_eval --strategy derived_trainability
azari dataset sample-dataset-review --dataset-name azari_eval
azari dataset export-dataset-jsonl azari_eval --split train --export-name azari_eval_train

Execute a tool capability directly:

azari run workspace.inspect_structure

Validation and QA

The repository includes validation coverage for:

• Desktop shell behavior.
• Startup and packaged smoke checks.
• Input routing and reasoning.
• Tone-mode separation.
• Conversation, project, and memory continuity.
• Local knowledge routing.
• Tool and ANH routing.
• Persistence and saved-session behavior.
• Safety and refusal behavior.
• Dataset curation and export.
• Scripted long-conversation evaluation.

Recent local validation snapshots have included focused suites with hundreds of passing tests and successful packaged rebuilds. Treat those as local release-readiness evidence, not as a permanent guarantee. Any release candidate should still run the focused test slices, packaged smoke validation, and manual desktop QA before distribution.

Useful validation commands:

python -m pytest
python -m azari.validation.system_sweep --mode full
python -m PyInstaller main.spec

Known Limits

• Local knowledge is broad but not universal.
• Some content-generation behavior depends on provider configuration.
• Live external research requires configured sources or tools.
• Long-conversation quality is now evaluated locally, but real packaged 20-30 turn scripted sessions should still be run as release QA.
• Packaged behavior should be smoke-tested after rebuilds that touch runtime paths, desktop startup, tools, or persistence.
• The executable is large because it bundles local runtime dependencies and tool support.

Bottom Line

Azari v2 is a local-first desktop AI assistant with a real app shell, local persistence, memory, curated knowledge, tool routing, ANH support, evaluation surfaces, and explicit capability boundaries.

It is meant to be useful, inspectable, and honest: conversational when the user is chatting, tool-capable when a supported workflow is needed, and clear when local knowledge or runtime support is not enough.