Support & FAQ

AuraLinter uses a LangGraph multi-agent state machine running on a FastAPI backend. When you submit a request from the iOS app, a Router agent classifies it (code generation, RAG query, or audio analysis). For code generation, a Coder agent writes C++ DSP kernels, a Critique node verifies them with clang++ -fsyntax-only, and a Judge decides whether to accept or retry. The entire process — node transitions, tool invocations, compilation results — streams to your iPhone in real-time via Server-Sent Events (SSE).

AuraLinter is designed to work with any conforming backend. You have two options:

Self-hosted: Clone the open-source backend, run docker compose up -d db for Postgres, then launch with uv run uvicorn app.main:app --reload. Point your iOS app's Settings to http://localhost:8000 (or your server's URL). Full control over models, rate limits, and data.

Managed: App Store builds use AuraLinter's hosted service, currently at https://auralinter.fly.dev. The service handles model inference, GPU processing, and the PostgreSQL database. Custom backend controls are available only in developer builds.

The default tiered model configuration uses:

Router: Claude Haiku 4.5 — fast, low-cost request classification.
Coder: Claude Opus 4.6 — high-quality C++ DSP kernel generation.
Judge: Claude Opus 4.6 — careful acceptance/rejection decisions.
Answer: Claude Sonnet 4.6 — balanced quality and cost for RAG responses.

All models are served via Amazon Bedrock by default. The provider is switchable via the LLM_PROVIDER environment variable — direct Anthropic API is one line away. If you self-host, you can configure every tier independently via environment variables.

AuraLinter's RAG system uses hybrid search over a pgvector-enabled PostgreSQL database. It combines two retrieval strategies and merges them with Reciprocal Rank Fusion (RRF):

Dense (semantic): HNSW-indexed vector search using Voyage AI embeddings (1024-dim). Finds conceptually similar passages even with different keywords.
Sparse (keyword): PostgreSQL full-text search via ts_rank, weighted over title and body columns. Matches exact terminology.

Every answer includes numbered source citations from the ingested DSP corpus (textbooks, papers, technical notes), so you can verify exactly where the information came from.

Audio is uploaded to the backend and staged in temporary files while it is analyzed or enhanced. Synchronous-session files normally expire after about 30 minutes; long-job files may remain for up to about four hours. Saved projects and media remain in the App's private storage until you delete the project or remove the App. Completed run records are stored separately. See the Privacy Policy for full details.

AuraLinter requires iOS 17.0 or later and runs on any iPhone or iPad that supports iOS 17. The app uses SwiftUI, AVAudioEngine, URLSession, and system frameworks exclusively — no third-party dependencies on the device. The compute-intensive work (LLM inference, code compilation, vector search) runs on the backend, so the iOS app itself is lightweight. An active internet connection is required to communicate with the backend.

Yes. The backend is open-source Python (FastAPI + LangGraph) and designed to be self-hosted. You'll need:

1. Python 3.12+ with uv for dependency management.
2. PostgreSQL with the pgvector extension (Docker: pgvector/pgvector:pg17).
3. LLM API access — either Amazon Bedrock credentials or an Anthropic API key.
4. (Optional) A Voyage AI API key for generating embeddings during corpus ingestion.

Run docker compose up -d db followed by uv run uvicorn app.main:app --reload. Deploy to Fly.io, AWS, or any Docker-capable platform. Configure your iOS app's Settings to point at your backend endpoint. See the repository README for full setup instructions.

The managed service currently authenticates requests with an X-Api-Key header stored in the iOS Keychain. Production builds do not expose backend URL or credential editing. Developer and self-hosted builds can configure their own backend and keys; unauthenticated mode is appropriate only for isolated local development. Per-install credentials and account-scoped access are planned before public release.

Rate limits are configurable via backend environment variables. The defaults include:

Rate limiting: Enabled via RATE_LIMIT_ENABLED=true. Limits requests per client per time window to prevent abuse.
Loop caps: The agentic code generation loop has a maximum iteration count to prevent runaway costs. The critique loop is bounded — it will produce a best-effort result rather than looping indefinitely.
Audio size: Synchronous analysis has a 600-second (10-minute) cap; long jobs cap at 900 seconds (15 minutes). These are configured server-side.

All limits are env-configurable when self-hosting. Managed backend users should contact us for higher limits if needed.

Every generated C++ DSP kernel passes through a clang++ -fsyntax-only verification step. This confirms the code compiles syntactically but does not guarantee it is logically correct, numerically stable, sandboxed from the rest of the service, or free of undefined behavior at runtime. The judge agent evaluates correctness, but AI-generated code should be reviewed before use in production audio pipelines. Treat compiler verification as a useful first-pass filter — not a formal correctness proof.

The iOS app does not include third-party advertising or behavioral analytics SDKs. It sends audio, prompts, and service activity to the managed backend to provide the requested features, and it stores saved project media locally. Credentials are stored in the device Keychain. See our Privacy Policy for full details.

Use the Contact page to reach us. Select "Bug report" for app issues (please include iOS version, device model, and steps to reproduce) or "General inquiry" for questions. For backend issues when self-hosting, check the repository's issue tracker on GitHub. The contact form includes a verification slider to prevent spam — slide it fully to unlock the submit button.