How Pocket Code's AI Works Under the Hood

Pocket Code's artificial intelligence isn't a generic chatbot glued to an editor. It's an integrated system that understands your project, your code, and the modules you're using. In this post, we'll tell you how we built it.

General Architecture

The AI system has three main layers:

1. Smart Autocomplete (LSP)

Autocomplete works through the Language Server Protocol (LSP). When you type code, the editor sends context (current file, cursor position, open files) to the AI model, which returns completion suggestions.

What makes our autocomplete different:

• Full project context: It doesn't just see the current file, but the project structure, imports, and dependencies
• Optimized models: We use temperature 0.0 and topK=1 for maximum suggestion accuracy
• Smart cache: We separate cache by model (chat vs completion) to avoid context contamination
• Fill-in-the-Middle (FIM): The model receives code before AND after the cursor for more precise suggestions

2. Contextual Chat

The AI chat isn't a simple prompt-response. When you ask a question:

1. The current open file is analyzed
2. Selected code is extracted (if there's a selection)
3. The project structure is included
4. Everything is sent as context to the model

This means you can ask "what does this function do?" without having to copy and paste code.

3. Module Tools (Tool Calling)

This is the most powerful part. We've registered 15 tools that AI can invoke to interact directly with the app's modules:

Tool	What it does
create_file	Creates files in your project
run_terminal_command	Executes commands in the integrated terminal
query_database	Queries SQLite databases
preview_layout	Previews layouts in the designer
git_status	Checks Git status
run_tests	Runs unit tests
install_package	Installs dependencies
read_file	Reads project files
search_code	Searches the entire codebase
refactor_symbol	Safely renames symbols

When you tell the AI "create a ViewModel for the user list", it doesn't just generate code — it creates the file, places it in the correct folder, and updates the necessary imports.

Security

All execution goes through strict validations:

• Command injection: Terminal commands are sanitized against injection
• Sandboxing: Commands can only run within the project directory
• Timeouts: Every operation has a time limit to prevent zombie processes
• Null safety: All tools validate null values before executing

Supported Models

Pocket Code works with multiple AI providers under a BYOK (bring-your-own-key) or OAuth login model through the official CLIs. Pocket Code is not an AI provider: every request goes directly from the device to the provider you pick, and usage is billed by the provider under their policy.

• Gemini (Google) — API key or OAuth via the Gemini CLI. Default model, excellent for Kotlin/Android
• OpenAI / Codex (GPT-4, o-series) — API key or OAuth via the Codex CLI
• Anthropic Claude (Sonnet, Opus, Haiku) — API key or OAuth via the Claude Code CLI
• GitHub Copilot — login with your GitHub account (13 multi-vendor models)
• Local models — Via Ollama for offline use

Users connect their account or API key in Settings > API Keys.

What's Coming

We're working on:

• RAG (Retrieval-Augmented Generation): So the AI searches Android and Kotlin documentation before answering
• Multi-file editing: Edit multiple files in a single operation
• Prompt templates: Reusable prompt templates for common tasks

Conclusion

Pocket Code's AI isn't a bolted-on component — it's an integral part of the development experience. Every app module (terminal, database, designer, Git) is connected, and the AI can orchestrate them all.

You can see the complete development status in our status post.