VS Code Extension
Find the official listing, install the extension, connect a supported model and troubleshoot your first coding workflow.
Open setup guideLoading OpenMindAI
Loading OpenMindAI
Start with installation, then learn how local storage, models, projects, updates and troubleshooting fit together.
The setup sequence intentionally prepares storage, hardware detection, runtime and model state before marking the workstation ready.
Each area below maps directly to the product architecture and repository documentation.
Find the official listing, install the extension, connect a supported model and troubleshoot your first coding workflow.
Open setup guideInstall OpenMindAI, choose the AI data root, detect hardware, prepare the runtime, select a model and verify it before use.
Open installation guideUnderstand OPENMINDAI_ROOT, portable mode, external-drive behavior and why missing storage should never look like lost data.
Covered in the official READMELearn how model files stay outside Git, how local recommendations work and how capability routing keeps the interface simple.
Covered in the official READMEWork with attached folders, scoped file edits, terminal permissions, validation and Git inspection from the project workspace.
Covered in the official READMEConnect services in Settings → Apps, then use them through normal language in Chat or Project Work without provider/action pickers.
Connected apps contractUse official release assets, published checksums, signed update metadata and the repository security pipeline.
Covered in the official READMEConnected-service secrets and OAuth tokens belong in the operating-system credential store, not chat history.
Use official project releases and verify published checksums when they are available.
Large model weights are downloaded separately and deliberately excluded from normal Git history.
Local-first AI for Windows, macOS, Linux, Android, and iOS
OpenMindAI is a local-first AI workspace built for people who want useful AI on their own devices. You can use it for everyday chat, reasoning, documents, vision, voice, research, local projects, and development work without making a cloud AI service the default for every task.
This guide explains how to use OpenMindAI after installation. For operating-system-specific setup instructions, see the separate Installation Guide. For hardware recommendations, see System Requirements. Privacy and legal information are maintained separately in the Privacy Policy and Terms of Use.
Website: https://www.openmindai.org
Desktop source baseline: OpenMindAI v3.0.1
Mobile source baseline: OpenMindAI Mobile 0.0.1+1
Documentation updated: September 2026
If you are new to OpenMindAI, you only need three things before you can start:
Once the model is installed, open Chat, type a message, and send it. If the selected model is running locally, the response is generated on your device.
You do not need to configure every feature on day one. A good first setup is one general-purpose model, normal Chat, and conversation history. Add Think, Vision, Search, Projects, or additional models when you actually need them.
Tip: Start small. A lightweight model is easier to run and is often enough for normal writing, explanations, summaries, and everyday questions.
OpenMindAI separates the application from the AI model.
The application provides the interface, conversation history, model management, files, Projects, settings, and other tools. The local model provides the AI inference. On desktop, a local runtime loads the selected model and uses the available CPU or supported GPU resources. On mobile, the application uses an on-device inference stack designed for tighter memory and battery limits.
This design gives you more control over what runs on your device and which model you use.
A normal local request follows a simple path:
Your prompt
↓
OpenMindAI
↓
Selected local model
↓
Response generated on your device
↓
OpenMindAI chat
Network-enabled features use a different path. For example, Search must retrieve current public information from the web before the local model can work with it.
Your question
↓
OpenMindAI Search
↓
Public web retrieval
↓
Retrieved evidence
↓
Local AI model
↓
Answer
This is why OpenMindAI is described as local-first, not offline-only.
The desktop and mobile applications share the same local-first approach, but they are designed for different kinds of work.
| Area | Desktop | Mobile |
|---|---|---|
| Local Chat | Yes | Yes |
| Think / reasoning | Yes | Yes |
| Search and Research | Yes | Yes |
| Documents | Yes | Yes |
| Vision | Supported with compatible model | OpenMindAI Lens |
| Voice | Supported | Hear and Speak |
| Local model management | Yes | Yes |
| Projects | Yes | Not the primary mobile workflow |
| Project Agent | Yes | Desktop-focused |
| Local file editing | Yes, inside approved workspace | Limited to mobile workflow |
| Connected Apps | Full desktop integration set | More limited than desktop |
| Canvas | Supported artifact/media workflows | Local SVG Canvas workflow |
| Large models | Better suited | Limited by phone memory and thermals |
Desktop is the better choice for long sessions, development, large documents, Projects, local agents, and larger model libraries.
Mobile is the better choice when you want a private AI assistant in your pocket: quick Chat, Think, voice, camera input, documents, Search, Research, and smaller local models.
The first run prepares OpenMindAI for local inference.
On desktop, OpenMindAI guides you through the local data location, profile setup, hardware detection, runtime preparation, and model installation. The selected storage location is important because model files can be several gigabytes.
On mobile, onboarding checks device capability and storage before provisioning the first local model. The current mobile setup starts with OpenMindAI Nano, a lightweight model of approximately 429 MB, instead of automatically downloading a multi-gigabyte model.
When setup is complete, test the installation with a simple prompt such as:
Explain in two sentences what local AI means.
If you receive a response, the basic local inference path is ready.
For a complete platform-by-platform setup process, use the OpenMindAI Installation Guide.
The Model Manager is where you install and maintain local AI models.
A model is a large file containing the parameters used for inference. OpenMindAI keeps these files separate from the application so you can choose only the models you want.
The Model Manager handles the normal model lifecycle: download, progress tracking, cancellation, supported resume behavior, verification, activation, and removal.
On mobile, models are stored in app-private storage. On desktop, model files can live under the OpenMindAI data root selected during setup.
| Model | Approximate Size | Typical Use |
|---|---|---|
| OpenMindAI Nano | 0.43 GB | First-run, lightweight Chat |
| OpenMindAI Swift | 1.28 GB | Faster general use |
| OpenMindAI Core | 2.50 GB | General-purpose local AI |
| OpenMindAI Titan | 5.20 GB | Larger local model |
| OpenMindAI Reasoning Mini | 1.12 GB | Lightweight reasoning |
| OpenMindAI Reasoning | 4.68 GB | Deeper reasoning |
| OpenMindAI Lens | 2.78 GB + projector | Vision and image understanding |
Model sizes and catalog entries can change between releases.
Important: Disk space is not the same as runtime memory. A model that fits in storage can still be too large for the available RAM.
Use Model Manager to remove a model you no longer need. Deleting a model frees storage but does not normally delete your conversation history.
If you need the model again later, you can download it again.
Avoid manually moving, renaming, or deleting model files while OpenMindAI is running. Doing so can leave the model registry or installation metadata in an inconsistent state.
There is no single best model for every device or task.
Smaller models start faster, use less RAM, consume less battery, and are a good fit for everyday Chat. Larger models usually need more memory but can be better for complex reasoning, longer context, or more demanding work.
A vision request needs a vision-capable model. A reasoning-heavy task is better suited to a reasoning model. Mobile devices should normally use smaller models than desktops.
OpenMindAI's routing system can take model capability and device limits into account, but the following rule is useful:
| Need | Good Starting Point |
|---|---|
| Quick everyday questions | Lightweight general model |
| Writing and summaries | General-purpose model |
| Complex reasoning | Reasoning model |
| Screenshots or photos | Vision/Lens model |
| Coding | General or coding-capable model |
| Low-memory phone | Nano or another small model |
| Large desktop workload | Larger model if RAM/GPU allows |
If a model frequently fails to load or your device becomes very slow, choose a smaller model rather than forcing the larger one.
Chat is the default OpenMindAI mode.
Use it for normal questions, explanations, writing, planning, summaries, brainstorming, study help, technical assistance, or quick coding questions.
A conversation keeps its own context, so follow-up prompts can refer to earlier messages. Depending on the platform, you can stop generation, regenerate a response, edit an earlier prompt, attach a file, or switch models.
For example:
Explain this error in simple terms.
Now show me the safest way to fix it.
Rewrite the fix as a checklist.
All three messages belong to the same conversation, so the model can use the earlier context.
When Chat is using a compatible local model, it does not need an internet connection after the model and runtime are installed.
Use Think when the task needs more deliberate reasoning than normal Chat.
Good use cases include architecture decisions, debugging, multi-step analysis, technical comparison, difficult study problems, research interpretation, and planning.
Think may take longer than Chat and may use a reasoning-oriented model if one is installed.
Use Think when the quality of the reasoning matters more than the fastest possible response. For simple questions, normal Chat is usually more efficient.
Use Search when your question depends on information that may have changed.
Examples include current software documentation, recent releases, public news, product information, updated policies, or other time-sensitive topics.
Search retrieves public web evidence and makes that evidence available to the AI model. Because the retrieval step uses the internet, Search is not an offline feature.
Use Search when freshness matters. Do not use it simply because a question is difficult; Think may be more appropriate for a difficult question based on information you already have.
Privacy note: Avoid placing unnecessary confidential information into a Search query. Search is a network-enabled feature.
Deep Research is for questions that need more than one quick search.
It is useful when you want to gather information from several public sources, compare evidence, organize findings, or build a more complete answer.
Typical uses include literature exploration, technical research, product comparisons, market research, public-policy research, and technology evaluation.
Research uses the internet to collect evidence. The selected model then works with that evidence to produce the answer.
For best results, give Research a clear question and scope. A focused request such as:
Compare the current local inference options for desktop AI and explain the trade-offs for a 16 GB RAM system.
is more useful than:
Research AI.
You can attach supported documents and ask OpenMindAI to work with their content.
Current workflows support common formats including PDF, DOCX, Markdown, plain text, source code, JSON, YAML, and CSV.
Examples:
Summarize this report in five key findings.
Explain section 4 for someone new to the topic.
Compare the conclusions in these two documents.
Review this configuration file and point out likely problems.
Large documents use more context and memory. If a document is very long, ask focused questions or work through it section by section.
Text-based PDFs are easier to process than image-only scanned PDFs. Scanned documents may require OCR or a vision-capable workflow depending on the platform and document.
DOCX documents can be used as context for review, summarization, rewriting, and structured document work. Desktop artifact workflows can also create reusable document output when the relevant generation feature is available.
Source files, JSON, YAML, CSV, and similar text formats can be attached as context. When working with a full software project, use a Project instead of attaching many files one at a time.
Vision allows OpenMindAI to work with image content.
A compatible vision model can help explain a screenshot, inspect a diagram, understand a photo, read visual context, or answer questions about an image.
On mobile, this workflow is presented through OpenMindAI Lens. You can choose an existing image or capture one with the camera and then ask a question about it.
Examples:
What does this error message mean?
Explain this circuit diagram.
What is wrong with this UI layout?
Summarize the text visible in this image.
Some vision models require an additional multimodal projector file. OpenMindAI checks for the required component before starting the vision workflow.
Camera permission is only needed when you choose to capture a new image.
OpenMindAI includes two voice-oriented features.
Hear converts speech into text for use as a prompt. It is useful for dictation, quick ideas, accessibility, or hands-free mobile use.
Microphone permission is required when you use voice input.
The current mobile implementation uses local Whisper-based speech transcription.
Speak reads a generated response aloud using supported text-to-speech capabilities.
Use it when you prefer listening to a response, need hands-free use, or want accessibility support.
Voice availability and quality can vary by operating system and installed speech components.
Canvas provides a lightweight visual creation workflow.
The current mobile Canvas implementation can generate structured SVG-based visual content on the device. The generated result can be previewed, saved, and shared.
Canvas is useful for diagrams, simple visual concepts, structured graphics, and lightweight design output.
It is separate from heavier diffusion-based image generation. OpenMindAI does not silently switch a local Canvas request to a paid cloud image API.
OpenMindAI keeps normal conversation history locally.
History lets you return to earlier work instead of starting from scratch. Mobile currently supports chat search, rename, delete, export, and full-history cleanup.
Use meaningful titles for long-running conversations so they are easier to find later.
If a conversation contains sensitive information, remember that local data still depends on the security of your device. Use device encryption, a strong login, and biometric app lock where available and appropriate.
Deleting a conversation does not delete unrelated exported files or copies you saved elsewhere.
Projects are the desktop workspace for work that lasts longer than a single conversation.
A Project can keep project instructions, conversations, reference material, an attached local folder, files, and agent context together.
Projects are useful for:
Instead of repeatedly uploading individual files, attach the relevant project folder and let OpenMindAI work within that defined workspace.
Choose the folder that actually contains the work.
For a software project, attach the repository root. For research, attach the folder containing the relevant documents and notes.
Avoid attaching an entire drive when a smaller folder is enough.
A narrower scope is easier to understand, safer, and less likely to expose unrelated files.
The Project Agent can work with the files inside an approved Project workspace.
Depending on the permissions available, it can inspect directories, read files, create or modify files, rename or delete scoped files, review Git status and diffs, reason about failures, and run applicable validation.
A good Project Agent task is specific:
Inspect this repository and find why the profile page fails to load.
Do not change anything yet. Explain the cause first.
After reviewing the diagnosis, you can ask it to make the fix.
For development work, use Git before allowing automated changes. A clean branch gives you a reliable way to review or revert edits.
Recommended: Ask the agent to inspect first, change second, validate third.
OpenMindAI separates normal Chat from higher-risk local permissions.
Reading a conversation is not the same as editing a project file. Editing a project file is not the same as running a terminal command. OpenMindAI treats these capabilities as different permission levels.
An attached Project folder is the normal scope for local file work.
Broader Full PC + Terminal access should only be enabled when a task genuinely needs it. Terminal commands can install software, remove files, change configuration, modify repositories, or affect system state.
Before enabling broader access:
OpenMindAI's execution controls can limit command length, runtime, output, duplicate actions, and repeated failures, but safeguards do not replace user review.
You do not need the upcoming Code Agent to use OpenMindAI for development.
Today, Chat, Think, Projects, local files, Git context, and the Project Agent can already support many coding workflows.
You can use OpenMindAI to:
A useful development workflow is:
1. Open the repository as a Project.
2. Add project instructions if needed.
3. Work on a Git branch.
4. Ask OpenMindAI to inspect the relevant code.
5. Review the diagnosis.
6. Allow a scoped change.
7. Run tests or validation.
8. Review the Git diff.
9. Commit only the changes you understand.
The quality of coding help depends heavily on the selected local model and the amount of project context available.
A dedicated OpenMindAI Code Agent is planned as the next step in the development workflow.
The goal is to provide a coding-focused agent that can understand project structure, inspect related files, follow repository instructions, make controlled multi-file changes, reason about build or test failures, and validate its work before reporting completion.
A typical Code Agent workflow is expected to look like this:
Issue or task
↓
Inspect project
↓
Locate relevant files
↓
Plan change
↓
Edit approved files
↓
Run approved validation
↓
Review failures if any
↓
Repair and re-test
↓
Present final diff/result
The Code Agent is intended to remain local-first when a suitable local coding model is used. File access and terminal execution will remain permission-based.
Because this feature is still upcoming, its final interface, supported tools, and release scope may change.
For serious local coding-agent use, 16 GB RAM should be treated as a practical starting point, while 32 GB or more provides better room for larger models, project context, build tools, and validation.
Connected Apps extend OpenMindAI beyond local files.
Current desktop integration families include:
| Service | Typical Use |
|---|---|
| Google Workspace | Gmail, Drive, Calendar, Contacts |
| GitHub | Repositories, files, issues, pull requests, Actions, releases |
| Microsoft 365 | Outlook, OneDrive, Calendar, Contacts |
| Slack | Workspace communication |
| Notion | Workspace content |
| Dropbox | Files and storage |
| MCP | Compatible external tools and services |
Connected Apps are optional. Normal local inference does not require them.
Connections are managed through Settings → Apps on desktop.
When you authorize a connected service, grant only the permissions needed for the work you want to do.
OpenMindAI keeps connection secrets and OAuth tokens out of normal chat history and uses protected operating-system credential storage in the desktop architecture.
Use GitHub integration when the task depends on remote repository state. Local Git and local project files do not require a GitHub connection.
Review remote changes before merging into an important branch.
These integrations allow OpenMindAI to work with authorized productivity data. They require an internet connection and provider authorization.
MCP can connect OpenMindAI to additional tools and servers. Treat an MCP server as an external service: review who operates it and what permissions it receives before connecting sensitive resources.
OpenMindAI stores a significant part of its working data locally.
The OpenMindAI data root can contain:
You can place this data on a suitable secondary drive or external SSD when supported by your setup.
The desktop portable-storage design is intended to preserve the relationship between the application and the selected data root even when a removable drive uses a different drive letter or mount point.
If a configured storage drive is unavailable, do not create a second empty environment just to make the warning disappear. Reconnect or restore the configured storage location.
Mobile models and durable conversation attachments are kept in app-private storage.
The Android application deliberately avoids broad MANAGE_EXTERNAL_STORAGE access. Files are selected through system pickers instead of giving OpenMindAI unrestricted access to shared storage.
Use this table when you need to know whether a feature requires the internet.
| Feature | Internet Required? |
|---|---|
| Local Chat | No, after model/runtime setup |
| Think with local model | No |
| Local conversation history | No |
| Local document analysis | No, when the workflow is local |
| Local Project files | No |
| Project Agent local file work | No |
| Local vision | No, after required model/projector installation |
| Mobile Hear | No for the current local speech workflow |
| Mobile Canvas | No for current local SVG synthesis |
| Model download | Yes |
| Runtime download | Yes |
| Search | Yes |
| Deep Research | Yes |
| Application update check | Yes |
| GitHub | Yes |
| Google Workspace | Yes |
| Microsoft 365 | Yes |
| Slack / Notion / Dropbox | Yes |
| Remote MCP server | Yes |
An internet connection being available does not mean every Chat message is uploaded. At the same time, local models do not make network-dependent features magically offline.
OpenMindAI's privacy model starts with a simple rule: keep work local when the selected feature can run locally.
Normal local prompts and responses do not need to be sent to an OpenMindAI inference server simply to produce a response.
Current OpenMindAI Mobile uses Firebase Analytics for app-level usage analytics. The current mobile implementation states that prompts, responses, attachments, local model files, and chat history are not sent through the application's Firebase service.
Search, Research, connected services, model downloads, updates, and analytics are different because they involve network activity.
For the complete data-flow explanation, retention information, GDPR mapping, and privacy rights, read the OpenMindAI Privacy Policy.
The current mobile builds use the following permissions where relevant:
| Capability | Why It Is Used |
|---|---|
| Internet | Downloads, Search, Research, updates, analytics, connected features |
| Camera | Lens and user-initiated image/document capture |
| Microphone | Voice input |
| Notifications | Optional completion notifications |
| Biometrics / Face ID | Optional app lock |
| Photo Library on iOS/iPadOS | User-selected image attachments |
Core text Chat does not need Camera or Microphone access.
Keep OpenMindAI and your operating system up to date. Use disk or device encryption for sensitive work. Keep Project scopes narrow. Do not place passwords, tokens, or private keys in project instructions. Review agent changes before committing them.
External web content used by Search or Research is untrusted input. Treat it as evidence, not as authority to modify local files or ignore project rules.
Application updates and model updates are separate.
Updating OpenMindAI does not automatically mean every local model needs to be replaced.
Use the official release or updater path for application updates. Before a major upgrade, back up unique work and important project data.
When a new model version becomes available, review its size and hardware requirements before installing it.
If your existing model still works well, there is no requirement to replace it just because another model is newer.
Local-first data is still data that can be lost.
A failed drive, deleted app data, operating-system reset, lost phone, unsupported manual storage move, or damaged external SSD can remove local information.
Model files can usually be downloaded again. Your own conversations, project files, generated documents, and research work may not be replaceable.
Back up the things that are unique.
For software Projects, use Git. For research and documents, use your normal backup system. For portable OpenMindAI storage, keep a second copy of important user-created data.
First confirm that the model finished downloading and passed verification.
Then check available memory. A model can fit on disk but still need more RAM than the device has available.
Close memory-heavy applications and try again. If the problem continues, use a smaller model.
For vision, also confirm that the required multimodal projector is installed.
An out-of-memory error means the current model, context, attachments, or workload exceeds the memory available to the runtime.
Try one or more of the following:
Generation speed depends on the selected model, CPU, GPU, context length, quantization, system load, battery mode, and temperature.
A smaller model is usually the fastest fix.
On laptops and phones, sustained local inference can cause thermal throttling. Plug in the device for longer sessions and allow mobile devices to cool if performance drops significantly.
Check the network connection and free storage.
Use the resume or retry option in OpenMindAI when available. Avoid manually deleting .part or temporary model files unless troubleshooting instructions specifically require it.
If the final file repeatedly fails verification, remove the failed download through Model Manager and download it again.
Search and Research need internet access.
If normal local Chat works but Search does not, the problem is probably in the retrieval or network path rather than the local model.
Confirm that the device is online and that network access is not being blocked by a firewall, VPN, DNS filter, or operating-system restriction.
Check that the active model actually supports image input.
A text-only model cannot process an image.
If the model requires a multimodal projector, confirm that the projector is installed.
On mobile, check Camera or Photo Library permission if you are trying to capture or select an image.
Check Microphone permission in the operating system.
Make sure another application is not preventing microphone access.
On mobile, confirm that the local speech component is installed and initialized.
Confirm that the file is inside the folder attached to the Project.
The normal solution is to attach the correct Project folder—not to grant unrestricted access to the whole computer.
Do not treat the task as complete.
Read the test, build, formatter, or type-check error. Review the Git diff and identify whether the failure came from the new change or from an existing problem.
Revert unrelated or unsafe edits before continuing.
If your desktop AI data is on an external or secondary drive, confirm that the drive is connected and mounted.
Do not point OpenMindAI to a new empty folder simply because the original drive is temporarily unavailable. Doing so can make the application appear to have lost history or models even though the original data still exists elsewhere.
This section is for contributors and people building OpenMindAI from source. Normal users do not need these tools.
The current desktop application uses:
| Area | Technology |
|---|---|
| Desktop shell | Tauri 2 |
| Native backend | Rust 2021 |
| Frontend | React 18 + TypeScript |
| Build tooling | Vite 6 |
| Local database | SQLite via rusqlite |
| Async runtime | Tokio |
| Networking | Reqwest |
| Local inference | Native/local llama-compatible runtime paths |
| Documents | PDF and DOCX tooling |
| Speech/audio | Whisper and local/device speech tooling |
| Updates | Tauri updater |
| CI/security | GitHub Actions, CodeQL, npm audit, cargo audit |
The frontend communicates with the Rust backend through Tauri IPC. Privileged local operations, storage, runtime management, connected-app handling, and agent capabilities live in the native backend.
Current development documentation uses:
Clone and run:
git clone https://github.com/smshagor-dev/OpenMindAI.git
cd OpenMindAI
npm ci
npm run tauri dev
Frontend checks:
npm run check:version
npm run lint
npm run build
Rust checks:
cargo fmt --manifest-path src-tauri/Cargo.toml -- --check
cargo clippy --manifest-path src-tauri/Cargo.toml --all-targets --all-features -- -D warnings
cargo test --manifest-path src-tauri/Cargo.toml --all-features
Production build:
npm run build
npm run tauri -- build
OpenMindAI Mobile is built with Flutter and Dart.
The current source baseline requires Dart 3.12+ and Flutter 3.44+.
The mobile app includes local GGUF inference, local model routing, SQLite conversation history, document context, Lens, local Whisper voice input, TTS, Search/Research evidence handling, Firebase app analytics, and Canvas.
Typical local validation:
flutter pub get
dart run tool/prepare_platforms.dart
dart format lib test tool
flutter analyze
flutter test
Android debug build:
flutter build apk --debug
Android split release APKs:
flutter build apk --release --split-per-abi
iOS simulator build on macOS:
flutter build ios --simulator --debug
If OpenMindAI is not working as expected, first identify whether the problem belongs to the application, the model, the runtime, the device, or an online service.
That distinction makes troubleshooting much faster.
For example:
For current releases and source information:
Desktop repository: https://github.com/smshagor-dev/OpenMindAI
Website: https://www.openmindai.org
Contact: https://www.openmindai.org/contact
Use the following pages when you need more detail:
| Document | Use It For |
|---|---|
| About OpenMindAI | Product purpose, mission, and overall approach |
| Features | Full feature overview |
| System Requirements | Hardware, RAM, GPU, storage, and platform guidance |
| Installation Guide | Step-by-step installation on each platform |
| Documentation | Day-to-day product usage |
| Privacy Policy | Data handling, permissions, GDPR, analytics, and privacy rights |
| Terms of Use | Usage rules, licensing, responsibilities, and legal terms |
Local when possible. Connected when useful. Controlled by you.
Windows · macOS · Linux · Android · iOS
Start with the latest published release, then choose where your models and local data should live.