froggy-aura

# Froggy Aura **A local project-memory gateway for Cursor and AI coding agents.** Froggy Aura helps agents **do less rediscovery** — fewer orientation greps, fewer repeated file reads, fewer re-solved bugs — by combining **reusable project memory**, **MCP context serving**, and optional **OpenAI-compatible model proxying**. It remembers repo facts, solved bugs, architectural insight, and prior agent sessions, then serves that knowledge back so your agent can orient on what it already knows instead of mapping the same territory again. **Fewer context tokens are a side effect** of that: less exploration means less stuff in the prompt. > Stop paying your agent to rediscover your codebase. > **Work in progress.** The core idea is sound — agents *do* repeat discovery every session, and durable memory *can* cut that down — but real benefit depends heavily on **knowledge quality**, **retrieval tuning**, and ongoing maintenance. Aura is actively evolving the tools to build, measure, and improve that (gather, gap analysis, Stats → Benchmark, memory maintenance). Expect to invest some setup and tuning; small familiar repos may see less payoff than large or long-lived ones. ## The core idea Froggy Aura reduces repeated **repo discovery** in two complementary ways: 1. **Less discovery** — reusable project memory can replace repeated repo exploration, grep/search loops, and rediscovery of prior fixes — *when retrieval returns the right context*. The agent starts informed and reads only where memory has gaps. 2. **Cheaper model routing** (optional) — OpenAI-compatible passthrough can route model calls to local Ollama models or cloud models by alias. This is separate from memory; it helps with cost, not orientation. Aura works beside your agent as: - an **MCP memory server** for `prepare_session`, `search_knowledge`, and `record_solution` - an **OpenAI-compatible proxy** for `/v1/chat/completions`, `/v1/embeddings`, and `/v1/models` - a **local memory app** for facts, solutions, insight, transcripts, stats, and memory maintenance Agent work creates memory. Memory means less discovery next time — **if the memory stays accurate and retrievable**. Less discovery usually means fewer context tokens too, but discovery reduction is the point; token savings follow from it. ## Honest expectations | What we believe | What determines whether it pays off | |---|---| | Every new agent session starts cold and re-explores | **Knowledge quality** — stale or wrong memory can mislead the agent | | Durable facts + solutions beat re-deriving context each chat | **Retrieval tuning** — embeddings, limits, and per-project knobs affect hit rate | | Less discovery is the main win; fewer context tokens follow | **Maintenance** — gather refresh, verify, deprecate, and prune matter | | Cross-session fixes are valuable and often lost today | **Agent compliance** — the agent must call MCP tools before grepping | | | **Repo fit** — largest wins tend to be large, complex, or team-shared codebases | Aura is **not** a flip-a-switch optimization. It is a local memory layer you curate and tune over time. The product includes benchmark modes and gap analysis precisely because we want to *measure* less discovery — and the context tokens that go with it — not just assume them. ## How Aura operates Two views of the same system: what runs where, and how knowledge compounds. ### Runtime architecture ```mermaid flowchart TB Agent["Cursor / AI Agent"] subgraph Aura["Froggy Aura (localhost)"] MCP["MCP server\nprepare_session · search_knowledge · record_solution"] Mem["Project memory\nFacts · Solutions · Insight"] Proxy["OpenAI-compatible proxy\n/v1/chat/completions"] MCP --> Mem end subgraph Backends["Optional backends"] Ollama["Ollama — distillation, embeddings, local chat"] Cloud["Cloud models — frontier reasoning"] end Agent -->|"MCP tools"| MCP Agent -->|"chat completions (optional)"| Proxy Proxy --> Ollama Proxy --> Cloud Mem -.->|"background gather & distill"| Ollama ``` ### Knowledge lifecycle Memory is built between sessions and consumed during them. Quality at each stage affects retrieval downstream. ```mermaid flowchart LR subgraph Build["Between sessions"] G["Gather\nstructure · docs · code index"] I["Ingest\ntranscripts · record_solution"] D["Distill & synthesize\noptional Ollama"] G --> Store[(Local memory)] I --> Store D --> Store end subgraph Serve["During sessions"] P["prepare_session"] S["search_knowledge"] Store --> P Store --> S P --> Agent["Agent"] S --> Agent end subgraph Improve["Tune over time"] M["Memory maintenance\nverify · supersede · deprecate"] B["Stats → Benchmark\ngap analysis · retrieval tuning"] Agent -->|"record_solution"| Store B -.->|"adjust knobs"| P M --> Store end ``` ### Session flow — cold start vs. prepared start ```mermaid flowchart TB subgraph Without["Without useful memory"] W1["User asks a question"] --> W2["Agent greps & reads many files"] W2 --> W3["Rebuilds mental model from scratch"] W3 --> W4["May miss prior fixes in old chats"] end subgraph With["With tuned Aura memory"] A1["User asks a question"] --> A2["Agent calls prepare_session / search_knowledge"] A2 --> A3["Compact stack, facts, solutions, insight"] A3 --> A4["Targeted repo reads only where memory gaps remain"] end ``` Bad or stale retrieval can be **worse** than a cold start — the agent gets confident but wrong context. That is why tuning and maintenance are first-class, not afterthoughts. [Download latest Windows installer](../../releases/latest) --- ## Try it in 2 minutes 1. Download and install the latest Windows build from [GitHub Releases](https://github.com/froggy523/froggy-aura/releases/latest). 2. Launch **Froggy Aura** and **add a project** — give it a name and point it at your repo path. 3. Click **Install Cursor integration** on the project. 4. Start a Cursor Agent chat with a normal task, such as "how is auth wired up?" The installed workspace rule tells the agent to call `prepare_session` first — you do not need to name the tool. MCP endpoint: `http://127.0.0.1:3847/mcp` OpenAI-compatible endpoint: `http://127.0.0.1:3847/v1` Port configurable via `FROGGY_AURA_MCP_PORT`. --- ## Who this is for Froggy Aura is for developers who: - use Cursor or AI coding agents heavily - work in large, complex, or unfamiliar repos - watch agents grep and re-read the same files every session - want prior fixes to become reusable agent context - want local-first project memory instead of cloud-only memory - optionally want to route routine model work locally and reserve premium models for harder reasoning ## What this is not Froggy Aura is not a replacement for Cursor, not just a generic RAG search app, and not only an MCP server. It is a local gateway that helps agents **discover less** — reuse project knowledge, start sessions prepared, and optionally route model calls more deliberately. --- ## What Aura can reduce When memory quality and retrieval are good, Aura targets repeated **discovery** first: - Repo orientation greps and broad file reads - Search loops that cover ground the project already mapped - Re-solving known bugs - Rebuilding architectural context from scratch each session Side effects and secondary wins: - **Fewer context tokens** — less exploration means less file content and tool output in the prompt - Long prompt stuffing from undifferentiated context dumps - Cloud model usage for repetitive summarization and distillation (when using local prep) - Provider lock-in for IDE agent dialog (when using passthrough) ## What you get When memory is fresh, retrieval hits, and the agent uses MCP tools, the intended difference looks like this: | Without Aura | With Aura (tuned) | |---|---| | Agent greps and reads files to orient itself | `prepare_session` delivers stack, structure, facts, and relevant solutions in one call | | Past fixes live only in old chat logs | Solutions are distilled, tagged, and searchable across sessions | | Every session re-learns project conventions | **Insight** captures how the project works — architecture, approach, integration patterns | | No visibility into discovery vs. memory hits | Stats track MCP serves, exploration signals, and estimated context tokens | | IDE locked to one provider | OpenAI/Ollama passthrough lets agents use local or cloud models through Aura | | Useful agent conversations disappear | Finished sessions can become durable project memory | The goal is not flash. It is common sense: the agent should know your stack, remember what worked, and **stop rediscovering territory you already mapped** — **provided the memory layer earns that trust**. Fewer tokens in context are the natural consequence when that works. --- ## Two ways Aura helps ### 1. Less discovery through reusable memory AI coding agents are powerful, but every new session starts cold. They inspect the same files, rebuild the same mental model, and often miss hard-won context from previous fixes. Froggy Aura gives your agent a reusable memory layer: - **Facts** — what is true about the repo: docs, structure, registries, code index, and project conventions - **Solutions** — what fixed past problems, distilled from agent sessions and recorded outcomes - **Insight** — how to work effectively in the project: architecture, approach, integration patterns, and project-specific guidance - **MCP tools** — `prepare_session`, `search_knowledge`, `record_solution`, and related project-memory operations - **Local-first storage** — project memory stored under `~/.froggy/aura/` Instead of giving the agent more context, Aura aims to give it **better** context — compact, relevant, and maintained — so it **discovers less**. When retrieval hits, the agent skips broad exploration and reads only where memory has gaps. That usually means fewer context tokens too, but discovery reduction is what you feel in the session. ### Tuning and knowledge quality Most of Aura's long-term value lives here. The MCP server and passthrough are infrastructure; **what you store and how well it retrieves** is the product. **Building quality in** - **Gather** — refresh structure, docs, code index, and stack facts from disk. Run after major refactors. - **Transcript ingest + `record_solution`** — turn finished agent work into searchable solutions. Optional Ollama distillation improves summary quality over heuristics alone. - **Insight synthesis** — higher-level architecture and approach guidance, also Ollama-assisted when configured. - **Hybrid embedding search** (optional) — better paraphrase matching for `prepare_session` and `search_knowledge` when keyword search alone is not enough. **Keeping quality up** - **Memory maintenance** — verify, supersede, and deprecate entries that drift or conflict. - **Knowledge reconcile** — background worker finds duplicate or near-duplicate facts and solutions, auto-supersedes high-confidence pairs, optionally uses Ollama to judge ambiguous matches, and validates facts against referenced source files. - **Memory aging** — lifecycle settings under Settings → Memory. - **Coverage dashboard** — project overview shows what is pre-built vs. still missing. **Measuring and tuning retrieval** - **Stats → Benchmark** — compare control (no retrieval) vs. aura sessions; optional automatic alternation per chat with session-count balancing between arms. - **Per-project benchmark tracking** — context savings charts by project progression and by session length so you can see where memory pays off over time. - **Debug context-gap analysis** (Developer settings) — reports what Aura missed in MCP responses, with assimilation badges showing what was merged into the semantic map, promoted to solutions, or written as indexing prompts. - **Gap playbook** — recurring unhinted reads roll up into a playbook; **Run gap gather** writes gap-informed facts, **Export Cursor rule** emits a supplemental `.cursor/rules/froggy-aura-gap-playbook.mdc`, and **Reset learnings** clears derived artifacts while keeping gap reports. - **Retrieval tuning / RL** (developer) — per-project knobs nudged from gap reports. If retrieval quality is poor, expect the agent to grep anyway — you get the MCP response *plus* the exploration you were trying to avoid. Invest in gather, review distilled solutions, and use benchmark stats to see whether memory is actually reducing discovery. ### 2. Optional model routing (separate from memory) Most coding sessions include work that does not need a frontier model: summarizing old chats, organizing facts, and distilling transcripts into durable knowledge. Aura front-loads that prep into memory between sessions. Optional [Ollama](https://ollama.com) handles background distillation on your machine. OpenAI-compatible passthrough lets you route actual agent dialog to local or cloud models from one registry. Use memory to **discover less**. Use routing to make the model calls you still need **cheaper** — a separate lever from orientation and repo exploration. --- ## Local memory + model routing ### Cheap / local — memory and prep Good fit for high-volume, repetitive work Aura runs between agent sessions: - Summarize and **distill Cursor transcripts** into searchable solutions - **Gather repo facts** — structure, docs, code index, registries, and other deterministic project signals - **Distill prior solutions** from problem/solution text into durable knowledge - **Tag and organize** knowledge across facts, solutions, insight, and memory lifecycle - **Synthesize insight** — project, approach, and integration patterns from existing knowledge - **Prepare compact session context** via MCP so the agent starts informed instead of grepping cold Configure Ollama under **Settings -> Ollama** for transcript distillation and insight synthesis. When Ollama is off, heuristics still gather facts and build retrievable memory. Local models mainly improve the quality of distilled text. **Hybrid embedding search** (optional, off by default) stores vectors in SQLite per project and combines semantic similarity with keyword search for `prepare_session` and `search_knowledge`. Enable it under **Settings -> Ollama** when you want better match quality on paraphrased tasks; pull an embedding model such as `nomic-embed-text` first. Indexing and vector scans run in a background worker so MCP responses and the UI stay responsive. Keyword search still works when embeddings are disabled. ### Expensive / frontier — agent reasoning Reserve frontier tokens for work that benefits from deep reasoning in the IDE: - Complex multi-file reasoning and refactors - Architecture and design tradeoffs - Tricky debugging and root-cause analysis - Final implementation, review, and polish Point Cursor at Aura's passthrough endpoint (`http://127.0.0.1:3847/v1`) and register aliases in the model registry — for example, a local `aura/coder` for routine tasks and `aura/architect` routed to a cloud model for hard problems. MCP memory and passthrough run in parallel: cheap prep locally, frontier model only where it pays off. --- ## How it works 1. **Register** your workspace paths in the app. One project can map to several folders. 2. **Gather** scans the repo — structure, docs, code index, README, MCP maps — and builds a fact base agents can use immediately. 3. **Learn** from Cursor agent transcripts through hooks and from solutions the agent records when it finishes a fix. 4. **Serve** memory through an MCP server on `localhost`. With Cursor integration installed, an always-applied workspace rule instructs the agent to call `prepare_session` before grepping or reading the repo. 5. **Proxy** model calls through an OpenAI-compatible endpoint when you want Aura to route agent dialog to Ollama or cloud providers. 6. **Compound** project knowledge over time. Insight synthesizes facts and solutions into higher-level guidance, while memory maintenance keeps knowledge fresh. 7. **Tune and measure** — review gap reports, adjust retrieval settings, and use benchmark stats to confirm memory is earning its keep.  The overview dashboard shows what is already pre-built so agents need less repo exploration: stack detection, layout, code index, docs, chat solutions, and transcript imports — with coverage you can see at a glance. --- ## Features ### Facts, solutions, and insight Three layers of memory, each tuned for retrieval: - **Facts** — concrete knowledge gathered from your repo: docs, structure, registries, code index, and stable conventions. - **Solutions** — problems solved and how they were fixed, distilled from agent sessions and explicit records. - **Insight** — synthesized guidance about how the project is built and how to work in it.    ### Gather and ingest Run a full or incremental gather to refresh facts from disk. Import Cursor chat transcripts automatically. Aura processes sessions locally, with optional Ollama distillation, so useful outcomes become durable knowledge instead of disappearing into log files.   ### Cursor integration — out of the box Froggy Aura was built around **Cursor**, and integration is designed to be frictionless. From the project view, **Install Cursor integration** writes three things per workspace path: | What gets installed | Purpose | |---|---| | `.cursor/rules/froggy-aura.mdc` | Always-applied rule — agent should call `prepare_session` before repo exploration | | `.cursor/mcp.json` | Registers the `froggy-aura` MCP server and its tools | | `.cursor/hooks/` + `hooks.json` | Stop hook — records finished agent sessions for transcript ingest. It does not call `prepare_session`. | After integration, start Agent with a normal prompt. The rule handles session bootstrap; you do not need to ask for `prepare_session` by name. If you configure MCP manually without the rule, add similar guidance or expect to prompt for context yourself.  ### Why not just use Cursor rules? Cursor rules are static instructions. Froggy Aura is living project memory — when it is maintained and tuned. - Rules tell the agent how to behave. - Aura tells the agent what this project has learned. - Rules are manually maintained. - Aura can gather facts, import transcripts, record solved problems, and synthesize insight. - Rules are usually broad. - Aura can retrieve specific prior fixes and project facts on demand. There is overlap with Cursor's own indexing and rules. Aura's bet is that **durable, distilled, cross-session knowledge** — especially solutions and insight — adds value beyond what a single chat or static rule file provides. That bet pays off most on repos you work in repeatedly. ### MCP server — not just Cursor Aura exposes a standard MCP HTTP server. Any client that speaks MCP can connect — Cursor today, other IDEs and agent runtimes tomorrow. Point any MCP-capable client at `http://127.0.0.1:3847/mcp`. #### Key MCP tools | Tool | Purpose | |---|---| | **`prepare_session`** | Session start — resolve workspace, load stack/structure/insight/facts, and search knowledge for the user's topic in one call. Prefer this over calling tools separately. | | `search_knowledge` | Search facts, solutions, and insight mid-session before grepping or reading many files. | | `record_solution` | After a non-trivial fix, store problem + solution so future sessions need less exploration. | | `get_project_context` | Load stack, insight, and recent facts without a search query. | | `get_project_insight` | Return synthesized project, approach, and integration insight, optionally filtered by topic. | | `get_analysis_artifact` | Return a named analysis artifact: `dependency-map` (JSON), `decision-log`, `api-contracts`, `project-map`, `architecture-summary`, or `task-memory`. | Maintenance tools are also available for verifying, superseding, deprecating, and pruning memory. #### Example tool calls These are the JSON **arguments** an agent passes to each tool. Replace paths and ids with your workspace and project. **`prepare_session`** — start of an Agent turn; bootstrap context and search for the user's task: ```json { "workspace_path": "C:\\Users\\joe\\source\\repos\\my-app", "query": "fix flaky login tests in auth middleware" } ``` Context only, for example after a greeting or when orienting without a specific topic: ```json { "workspace_path": "C:\\Users\\joe\\source\\repos\\my-app" } ``` **`search_knowledge`** — mid-session lookup when the topic shifts: ```json { "query": "ECONNREFUSED MCP localhost 3847", "workspace_path": "C:\\Users\\joe\\source\\repos\\my-app", "limit": 8 } ``` **`record_solution`** — after fixing something non-trivial: ```json { "project_id": "35f5fdfc-c15c-49a7-a850-aeea8cee8c02", "problem": "MCP server returned ECONNREFUSED on port 3847 after sleep/resume.", "solution": "Froggy Aura was not running. Relaunch the app or enable login-at-startup in Settings; confirm http://127.0.0.1:3847/mcp responds.", "tags": ["mcp", "networking"], "refs": ["src/main/mcpRuntime.ts", ".cursor/mcp.json"] } ```  ### Optional local AI — Ollama Distill transcripts, synthesize insight, and route chat completions through local models — keeping sensitive or high-volume work off cloud APIs when you want to.  --- ## API passthrough — OpenAI and Ollama in your IDE Beyond MCP project memory, Aura exposes an **OpenAI-compatible API** on the same HTTP server as MCP: - `POST /v1/chat/completions` - `POST /v1/embeddings` - `GET /v1/models` Endpoint: `http://127.0.0.1:3847/v1` Point your IDE at Aura instead of a provider directly, and chat requests route to **Ollama** or **OpenAI-compatible cloud providers** based on a model registry you control. ### Why proxy agent dialog through Aura? MCP memory helps the agent ask for better context. The passthrough lets Aura sit in the actual model path. That means Aura can: - route routine work to local models - forward hard reasoning to cloud models - track model and token usage - observe completed sessions - turn useful outcomes into future memory - let one IDE workflow use multiple backends through model aliases The payoff: Agent, Chat, and Composer tasks in Cursor, or any OpenAI-compatible client, can run on local Ollama models or cloud APIs while Aura MCP still supplies project memory in parallel. ### Set up in Aura 1. Open **Settings -> Passthrough** and ensure passthrough is enabled. 2. Configure upstream providers — Ollama base URL under **Settings -> Ollama**, OpenAI API key and base URL under **Passthrough**. 3. Register custom model names in the model registry. Each entry maps an Aura-facing name, such as `aura/coder`, to a provider and backend model: ```json { "aura/coder": { "provider": "ollama", "model": "qwen3-coder:480b-cloud" }, "aura/architect": { "provider": "openai", "model": "gpt-4o", "providerOptions": { "reasoning": { "effort": "high" } } } } ``` `providerOptions` holds provider-specific fields that Aura merges into upstream chat/embeddings requests (for example OpenAI `reasoning.effort` via a `reasoning` object). Starter aliases ship with the app. Edit the JSON in Settings or in `~/.froggy/aura/model-registry.json`. Unregistered model names fall through to the default provider. ### Point your IDE at Aura In **Cursor** or a similar client: 1. Add a custom model, or override the OpenAI base URL in your provider settings. 2. Set the **OpenAI Base URL** to Aura's passthrough endpoint: `http://127.0.0.1:3847/v1`. 3. Choose a registry model name, such as `aura/coder`, as the model. 4. Use the IDE normally — agent tasks, chat, and completions flow through Aura to the configured backend. Aura translates between OpenAI and Ollama request/response formats, including streaming and vision payloads. Usage is tracked in **Stats -> Passthrough** so you can see which models and endpoints are active. > **Remote access:** Cursor's BYOK path may proxy through Cursor's cloud rather than your machine. To reach a local Aura instance remotely, expose it via an ngrok or Cloudflare tunnel and add matching host patterns under **Allowed tunnel hosts** in Passthrough settings.   --- ## Privacy and local-first behavior Froggy Aura stores project memory locally under `~/.froggy/aura/`. It does not upload your repo or transcripts by default. Optional external calls: - **Ollama** — local distillation, synthesis, and chat routing - **OpenAI-compatible passthrough** — only when configured and selected by model routing - **GitHub Releases** — update checks When passthrough is enabled, model requests flow through Aura before being forwarded to the selected provider. This allows Aura to track usage and support routing. Remote providers receive only the requests you route to them. You control which models/providers are used. --- ## Cost visibility Track what Aura is doing: - projects, facts, solutions, and sessions - MCP items served to agents, with **estimated tokens per response** and optional session IDs in the serve log - average MCP response size and calls per session in **Stats** - pipeline and transcript ingest activity - local vs cloud model activity - passthrough token usage - project knowledge growth over time When agents use stored knowledge instead of re-reading the repo, you can see it.     ### Measuring value (work in progress) Aura already tracks MCP items served, estimated tokens per response, passthrough usage, and benchmark comparisons (control vs. aura). The metrics we most want to nail — and do not claim to have perfected yet — are: ```text Repeated discovery avoided ← primary (grep/read loops, re-solved bugs) Estimated context tokens avoided ← side effect of less discovery ``` An approximate version of those would connect the dashboard directly to Aura's core promise. Until then, treat **Stats → Benchmark** and gap reports as the honest feedback loop: they show where memory reduced exploration, where the agent still dug around, and where tuning is worth the effort. **Project progression** and **session length** charts break savings down by workspace and session size; the gap profile aggregate highlights recurring misses and one-click actions to turn them into facts, rules, or semantic-map updates. Developer settings also expose a **heavy work log viewer** — searchable, line-numbered output from background gather, reconcile, semantic-map, and embedding jobs for diagnosing slow or stuck pipelines. --- ## Settings and data maintenance Configure themes, startup behavior, memory aging, model routing, embedding search, and host allowlists. Review and maintain stored knowledge from the project view. **Remove project** from the project list when you no longer need a workspace — Aura deletes the registry entry and that project's on-disk knowledge after confirmation.    --- ## Get started — Windows Froggy Aura is an **Electron desktop app**. A **Windows installer** is published with each release: 1. Download **`Froggy-Aura-<version>-setup.exe`** from [GitHub Releases](https://github.com/froggy523/froggy-aura/releases/latest). 2. Install and launch **Froggy Aura**. Optionally enable login-at-startup in Settings. 3. **Add a project** — give it a name and point it at your repo path.  4. Open the project and click **Install Cursor integration**, or configure MCP manually for other clients. 5. Start a Cursor Agent session with a normal task. The workspace rule directs the agent to call `prepare_session` first. Installed builds **auto-update** from GitHub Releases on startup and every four hours. > **Other platforms:** The app is built with Electron and runs on macOS and Linux for development (`npm run dev`). Windows is the primary packaged target today; cross-platform installers may follow. --- ## Data location Project memory is stored locally under: ```text ~/.froggy/aura/ ``` Override with the `FROGGY_AURA_HOME` environment variable. Your knowledge stays on your machine unless you choose to share it. --- ## Development ```powershell npm install npm run dev ``` Use **Run and Debug -> Launch Froggy Aura** in VS Code or Cursor. ### Build installer locally ```powershell npm run build npm run dist ``` Output: `dist/Froggy-Aura-<version>-setup.exe` ### Release Set a GitHub token with `repo` scope, then: ```powershell $env:GH_TOKEN = "ghp_your_token_here" npm run release ``` See `scripts/release.js` for flags such as `--dry-run`, `--skip-publish`, `--skip-push`, `--no-bump`, and `--allow-dirty`. | Script | Action | |---|---| | `npm run release:minor` | Minor version bump + full release | | `npm run release:major` | Major version bump + full release | | `npm run dist:publish` | Build `.exe` + publish to GitHub Releases without bump/tag | Publishing requires `GH_TOKEN` and matching `build.publish` settings in `package.json`. --- ## Suggested GitHub metadata **Description** ```text Local project-memory gateway for Cursor and AI coding agents (WIP): less repo discovery, MCP memory, retrieval tuning, optional OpenAI/Ollama routing. ``` **Topics** ```text cursor cursor-ai mcp mcp-server model-context-protocol ai-agents agent-memory token-optimization context-engineering context-compression openai-compatible ollama rag developer-tools electron typescript local-first project-memory ``` --- ## Project layout - `src/main` — Electron main process + auto-updater - `src/preload` — Preload bridge (`window.aura`) - `src/renderer` — React UI - `src/mcp` — MCP HTTP server and tools - `src/core` — Knowledge store, gather, distillation, search - `scripts/` — Version bump, verify, release --- ## Contributing Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, tests, and pull request expectations. Report security issues privately per [SECURITY.md](SECURITY.md). Planned directions are outlined in [ROADMAP.md](ROADMAP.md). --- ## License [MIT License with Commons Clause](LICENSE) — free to use, modify, and distribute, including in commercial development workflows. You may **not** sell Froggy Aura itself (or a product whose value comes substantially from this software). See [LICENSE](LICENSE) for full terms.