Effitask

A modern task manager with native AI integration · Kotlin Multiplatform · MCP · local AI

Effitask is a household / personal task manager that runs natively on Android and iOS from a single Kotlin Multiplatform codebase, persists state through Supabase, and gets its AI features from a Python MCP server you can run locally or self-host. There is no LangChain anywhere in this project — providers are wired directly to their official SDKs.

Why this exists

Most productivity apps either ship without AI, or bolt it on through a third-party orchestration framework that hides what's happening. Effitask takes a different position: a small surface area, the official AI provider SDKs, and the Model Context Protocol as the seam between mobile clients and AI capabilities. That setup keeps the door open to a privacy-first configuration (Ollama running on your own machine) while also working seamlessly with hosted models when you want stronger reasoning.

Architecture

flowchart LR
    subgraph Mobile["Mobile (Kotlin Multiplatform)"]
        AndroidApp["androidApp"]
        IOSApp["iosApp"]
        Compose["composeApp · Compose UI"]
        Shared["shared/{domain,application,infrastructure}"]
    end

    Supabase[("Supabase<br/>(auth + Postgres)")]

    subgraph MCP["MCP server (backend/python/ai)"]
        Tools["tools: list/create/update/delete tasks"]
        Resources["resources: tasks://household/{id}"]
        Orchestrator["orchestrator<br/>(auto-detect provider)"]
    end

    subgraph Providers["AI providers (direct SDKs)"]
        Ollama["Ollama (local)"]
        Anthropic["Anthropic"]
        OpenAI["OpenAI"]
    end

    AndroidApp & IOSApp --> Compose --> Shared
    Shared -- "CRUD (anon key)" --> Supabase
    Shared -- "AI tools (JSON-RPC over HTTPS)" --> MCP
    MCP -- "service role" --> Supabase
    Orchestrator --> Ollama
    Orchestrator --> Anthropic
    Orchestrator --> OpenAI

Loading

The mobile client talks to Supabase directly for everyday CRUD (using the public anon key + Row Level Security). For AI-augmented operations ("suggest breakdown for this task", etc.) it goes through the MCP server, which holds the Supabase service-role key and the provider API keys. The client never sees a model key.

Modern AI integration callout

Effitask demonstrates 2026 mobile + AI integration patterns: KMP clients (Android + iOS) connecting to an MCP server that orchestrates Anthropic Claude, OpenAI, and Ollama-based local models. No LangChain — direct SDK integrations and the Model Context Protocol for composability and privacy.

Module overview

Path	Purpose
androidApp/	Android entry point, manifest, build-time credentials generation
iosApp/	iOS (SwiftUI) shell that hosts the Compose Multiplatform UI
composeApp/	Shared Compose Multiplatform UI, navigation, presentation state
designsystem/	Shared design tokens & reusable components
shared/domain/	Pure entities and repository / service interfaces
shared/application/	Use cases — depend on domain only
shared/infrastructure/	Supabase repositories, Ktor HTTP, Koin wiring, McpHttpClient
backend/python/ai/	MCP server, providers (Anthropic / OpenAI / Ollama), orchestrator
backend/python/worker/	Existing FastAPI + NetworkX scheduler service
backend/kotlin/	Lightweight Ktor gateway proxying to the Python services

Tech stack

Tech	Why
Kotlin 2.x + Compose Multiplatform	One UI codebase for Android + iOS without giving up native rendering
Ktor (client)	KMP-native HTTP, reused for MCP transport (no extra deps)
Supabase	Postgres + auth + RLS without a custom backend; the right "boring" persistence layer
Koin	Tiny KMP-friendly DI — no kapt, no annotation processors
MCP (mcp Python SDK)	Standard protocol for AI tool exposure; works with Claude Desktop and mobile clients
Anthropic SDK	Direct, official client for Claude models
OpenAI SDK	Direct, official client for GPT models
Ollama	Local-only fallback; keeps task data on-device when developer prefers it

Quickstart

1. Clone and configure

git clone https://github.com/jcellomarcano/effitask.git
cd effitask
cp .env.example .env
# Edit .env: fill in SUPABASE_URL + SUPABASE_ANON_KEY + SUPABASE_SERVICE_ROLE_KEY
# (Optional) set ANTHROPIC_API_KEY or OPENAI_API_KEY, or run Ollama locally

See .env.example for the full env var inventory.

2. Run the MCP server

cd backend/python/ai
python3.12 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

# stdio transport (Claude Desktop / local agents):
python -m mcp_server.server

# Streamable HTTP transport (mobile / remote clients):
python -m mcp_server.server --transport http --port 8765

3. Build the mobile app

# Android (debug)
./gradlew :androidApp:installDebug

# iOS — open iosApp/iosApp.xcodeproj in Xcode and run the "Effitask" scheme,
# or:
xcodebuild -workspace iosApp/iosApp.xcworkspace -scheme Effitask -configuration Debug build

4. Verify everything

./gradlew build
cd backend/python/ai && pytest -q
cd ../worker && pytest -q

Privacy & local AI

Effitask is designed so you can keep AI inference on your own machine if you want to. The orchestrator's auto-detect probes a local Ollama instance first; only if Ollama is unreachable does it fall back to remote providers. That decision is per-deployment, not per-user — operators choose their trust model up front via env vars.

When you run Ollama locally:

• Task content for AI features never leaves your machine.
• The MCP server still mediates Supabase access (so the service-role key doesn't ship with the mobile app), but no third-party model provider is involved.

Roadmap

• KMP UI + Supabase auth + task CRUD
• MCP server with task tools
• Anthropic / OpenAI / Ollama providers with auto-detect orchestrator
• Mobile McpClient integrated into Koin module
• First user-facing AI feature: "Suggest breakdown" in CreateTask
• iOS CI on macOS runners
• Streaming tool responses (server-sent events)
• Multi-household role propagation in MCP tool auth

License

MIT — see LICENSE.

Contributing

See CONTRIBUTING.md and CODE_OF_CONDUCT.md. Security disclosures go to jcellomarcano@gmail.com.

Authors

Maintained by Jesús Marcano (@jcellomarcano) and contributors.