No API key. No cloud lock-in. Local-first AI.
You have an idea for an AI app. But existing options force you to:
- ✗ Get an API key (and manage costs)
- ✗ Build infrastructure from scratch
- ✗ Choose between "too simple" (Ollama) or "too complex" (vLLM)
- ✗ Understand quantization, model selection, and hardware tiers
IntelliYash solves this with three facts:
- Your machine already has enough power to run modern AI models
- You shouldn't need a PhD to pick the right one
- You shouldn't ever pick manually — the system should decide for you
IntelliYash is a zero-config local AI studio:
- ⚡ Detects your hardware (RAM, CPU, disk) automatically
- 🎯 Routes each prompt by intent (chat vs. code vs. analysis)
- 📦 Downloads & unloads models in the background
- ⚙️ Generates full-stack apps from natural language (React + FastAPI)
- 💾 Stores everything locally — no cloud, no API key, ever
# Linux / macOS
./setup.sh
# Windows
setup.batThen open http://localhost:3000 and start typing.
That's it. No configuration. No model picker. No settings to debate.
- Chat with local models (context stays on your machine)
- Generate a full-stack app by describing your idea
- Monitor system health and model performance
- Optionally connect a cloud API key for fallback
- FastAPI backend with intent-based model routing
- Next.js frontend (React 18, TypeScript, Tailwind)
- SQLite + ChromaDB for chat history and RAG
- llama-cpp-python for GGUF inference on CPU
- Extensible plugin system for custom models/routes
┌─────────────────────────────────────────────────────────┐
│ 1. You type an idea: "Build me a todo app" │
├─────────────────────────────────────────────────────────┤
│ 2. SystemDetector probes: RAM=4GB, CPU=8-core, AVX2=yes │
├─────────────────────────────────────────────────────────┤
│ 3. ModelRouter decides: "tier=medium, task=code" │
│ → Load Qwen2.5-3B for code generation │
├─────────────────────────────────────────────────────────┤
│ 4. FastAPI generates a React + Python scaffold │
├─────────────────────────────────────────────────────────┤
│ 5. Your app is ready: frontend + backend, deployable │
└─────────────────────────────────────────────────────────┘
Every decision is logged in meta.reason — you see exactly why IntelliYash made each choice.
Next.js Frontend
↓ REST + SSE
FastAPI Backend
├─ SystemDetector → Detect hardware tier
├─ ModelRegistry → Curated models per tier
├─ ModelRouter → Intent classifier + smart routing
├─ ModelManager → Download/load/unload GGUF models
├─ Optimizer → Background memory watcher
├─ HealthMonitor → Auto-restart on crash
└─ LLM Service → Inference + tool calling
intelliyash/
├── backend/
│ ├── app/
│ │ ├── main.py # FastAPI app, lifespan management
│ │ ├── config.py # Settings from environment
│ │ ├── core/
│ │ │ ├── system_detector.py
│ │ │ ├── model_registry.py
│ │ │ ├── model_manager.py # llama-cpp-python wrapper
│ │ │ ├── model_router.py # Intent classifier
│ │ │ └── optimizer.py # Background memory manager
│ │ ├── api/
│ │ │ ├── chat.py # /api/chat (SSE)
│ │ │ ├── models.py # /api/models/list
│ │ │ ├── system.py # /api/system
│ │ │ └── health.py # /api/health
│ │ ├── db/
│ │ │ └── database.py # SQLite ORMs
│ │ └── services/
│ │ └── llm_service.py # LLM inference wrapper
│ ├── requirements.txt
│ └── run.py
├── frontend/
│ ├── app/
│ │ ├── page.tsx # Landing + chat
│ │ ├── models/page.tsx
│ │ ├── settings/page.tsx
│ │ ├── layout.tsx
│ │ └── globals.css
│ ├── components/
│ ├── lib/api.ts
│ ├── package.json
│ └── tailwind.config.ts
├── scripts/
│ └── healthcheck.py
├── setup.sh / setup.bat # One-command install + run
├── deploy.py # GitHub + cloud deployment helpers
├── test_system.py # E2E test
└── README.md
./setup.sh # All-in-one install
# or
./setup.bat # Windowssudo cp scripts/intelliyash.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl start intelliyashpython deploy.py # Automated cloud setup| Tier | Available RAM | Default Model | Runtime Memory |
|---|---|---|---|
| tiny | < 1.5 GB | Qwen2.5-0.5B | ~0.9 GB |
| mini | 1.5 – 2.8 GB | Qwen2.5-1.5B | ~1.8 GB |
| medium | 2.8 – 5.5 GB | Qwen2.5-3B | ~3.2 GB |
| large | ≥ 5.5 GB | Qwen2.5-7B | ~6.5 GB |
- Open the app → It auto-detects your system → Picks a model → Works
- No manual model selection, no quantization debates, no setup wizards
- All model inference runs on your CPU/GPU
- Chat history stored locally (SQLite)
- Optional cloud fallback only if you enable it
- Chat prompts → Fast model (sub-2s first token)
- Code questions → Larger context model
- Long-form analysis → Highest quality model available on your tier
- Type an idea → Get a deployable React + FastAPI app
- Includes authentication, database schema, API routes
- Ready to customize and deploy
- Every conversation is saved locally
- Jump back into any chat anytime
- Export conversations as markdown
The AI landscape today forces you to choose:
- Ollama & LM Studio: Great, but you have to hand-pick models
- Cloud APIs: Expensive, slow, data lives on someone else's server
- Build from scratch: Too much infrastructure, too much complexity
IntelliYash fills the gap: The ease of a web UI + the intelligence to make smart decisions + the simplicity of running locally.
Built for:
- Developers who want full control without complexity
- Non-technical users who just want AI to work
- Indie makers who need to build and deploy fast without vendor lock-in
Contributions welcome! Areas we're exploring:
- Multi-GPU support
- Additional model registries (Llama, Mistral, etc.)
- Web UI for model management
- RAG + knowledge base features
See CONTRIBUTING.md for details.
- ✅ Real and working: Backend, frontend, system detection, model registry, manager, router, chat persistence, setup scripts, and tests are full implementations
- ✅ First model download is online: Once cached locally, the system runs fully offline
- ℹ️ Needs your config:
deploy.pyneeds your GitHub / Render / Vercel tokens if you want cloud deployment - ℹ️ Cloud fallback optional: Connect an API key in Settings only if needed for advanced tasks
See ARCHITECTURE.md for deeper technical details.
MIT © 2025 IntelliYash
./setup.sh
# Open http://localhost:3000
# Type an idea, hit Enter
# Watch your app scaffold in real-timeQuestions? Open an issue on GitHub or check the docs for deep dives.
Ready to escape vendor lock-in? You're 2 minutes away from your first local AI app.
