Why Code Assistant
AI shouldn't just generate code — it should understand where that code lives
Grounded in your Git repositories and development standards, it understands the project context and answers accurately. Source stays protected in an on-premise environment, and an open architecture with no lock-in to a single AI model leaves you free to choose the LLM that fits your organization.
Understands the whole project
It learns not just the code but APIs, database schemas, and policy documents, so it can tell you what to build and where, at code level.
On-premise security
Installed on your own infrastructure, so source and data never leave. Access is controlled by GitLab account.
Model-agnostic
A managed AI gateway lets you pick and swap the LLM, so you keep pace as the AI ecosystem shifts.
Business Value
Development productivity and operational stability, together
Project-specific code comprehension and safe on-premise operation raise development speed while cutting maintenance cost.
New developers onboard faster
Weeks to months for a new hire to understand the legacy code
Ask the project code directly and grasp classes, APIs, database, and call flow immediately
Source code never leaves the building
Using an external AI service means shipping source code out, with the security concerns that follow
Code and data stay internal in an on-premise or air-gapped environment
Answers that fit your project
Generic code explanations from a general-purpose AI
Answers grounded in your project code, citing the actual components, APIs, tables, and source files
Maintenance productivity rises sharply
Code exploration and analysis that depends on one person's experience
One question surfaces the related code, call relationships, and blast radius
Core Capabilities
Core capabilities
Capabilities built on learning your code, APIs, and schemas, so answers land in your project's context.
Repository-grounded answers
Repository-Grounded
Select a GitLab repository and answers are grounded in that codebase. It references the real components and file structure to show how to reuse them and how to implement.
Schema-aware
Schema-Aware
It learns the database schema and the relationships between tables — cardinality and descriptions included — so it points to exactly the tables and APIs a task needs.
Question decomposition
Question Decomposition
A question is broken into API, CODE, and TABLE parts, then recombined, producing a fuller and more precise answer than a single-shot response.
Code review and improvement
Code Review
It identifies problems in existing code and proposes concrete fixes at code level — authentication, error handling, performance — with example code.
Feature design support
Feature Design
It finds the components and patterns worth reusing and lays out the implementation steps with example code, connecting an idea to a real build.
Endpoint discovery
API Discovery
Across a large codebase, it finds the API endpoint and related controllers you need, with the exact path and how to use them.
How It Works
How it works
It indexes the repository into evidence, retrieves the context the question needs, and generates a code-level answer.
- 01
Repository indexing
GitLab repositories are indexed through full and incremental sync, learning code, APIs, database schemas, and artifacts as vectors.
- 02
Context retrieval (RAG)
The question is decomposed, related code, schemas, and documents are retrieved, and the answer is grounded in them.
- 03
MCP pipeline
The Model Context Protocol connects tools and context in a standard way, pulling in the information needed safely.
- 04
Code-level answer
Grounded in the retrieved evidence, it generates an answer at code level that fits your project's context.
The full structure — gateway-based authentication isolation plus indexing, RAG, and MCP — is documented in the architecture pages.
Read the Code Assistant architectureHow this differs from a general coding assistant
| General coding assistant | AI Code Assistant | |
|---|---|---|
| Project understanding | Generic answers — limited grasp of project context | Learns your code, APIs, schemas, and artifacts, so it understands the project context |
| Answer depth | Mostly high-level explanation | Code-level answers that point to the actual components, endpoints, and tables |
| Security | Often assumes transmission to an external cloud | On-premise and air-gapped install keeps source inside |
| Model choice | Locked to the vendor's model | A managed gateway lets you pick and swap the LLM |
Integration and deployment
GitLab integration
Sign in with a GitLab account and connect your repositories. A GitLab Duo hybrid setup widens language coverage.
On-premise deployment
Installed on your own GPU servers, with a managed AI gateway covering air-gapped environments.
Artifact RAG
Domain artifacts such as policy and design documents are added through RAG, so context beyond the code reaches the answer.
Technical Specs
Technical specs and integration
From how it connects to your existing development environment through to the core technical specifications.
Development environment (IDE)
A VS Code extension — inline completion, context menu, and diagnostics inside the editor
Repository integration
Connected to GitLab repositories, with real-time incremental indexing keeping the code current
Code comprehension
AST-based structuring — the codebase is learned through call and dependency relationships, not file by file
Hybrid search
Keyword (BM25) combined with semantic vector search, then AI reranking for accuracy
Document parsing
Unified parsing of xlsx, docx, ppt, PDF, HTML, and other artifacts, used as context
Tool and data integration
Heterogeneous systems and databases connected safely through the MCP standard
Models
On-premise self-hosting, embedding and reranker models, and your choice of LLM — swappable, model-agnostic
Security
Network separation and air-gap, RBAC access control, audit logs, and secure-coding practice
Use Cases
Use cases
How an AI Code Assistant that understands your code, APIs, and schemas gets used day to day.
Guidance for building a new feature
- Finds and presents reusable components and patterns
- Lays out the implementation steps with example code
- Points to the related APIs and tables, connecting into the design
API and schema discovery
- Locates the endpoints and controllers you need
- Confirms database tables, relationships, and cardinality
- Points precisely to the APIs and tables the task requires
Legacy comprehension and onboarding
- Explains a large codebase's structure at code level
- Surfaces undocumented logic together with its evidence
- Shortens the onboarding period for new hires
Code review and improvement
- Diagnoses problems in authentication, error handling, and performance
- Concrete improvements that include example code
- Pre-checks for rule and security violations
Frequently asked questions
- Does it learn our existing codebase?
- Yes. It indexes your GitLab repositories, turning code, APIs, database schemas, and artifacts into knowledge, and generates answers grounded in that repository. If you don't select a repository, you can still use it freely as a general AI chat.
- Is our source code sent anywhere external?
- No. AI Code Assistant is installed on-premise or in an air-gapped environment, so source and data stay inside your organization.
- Are we locked into a specific LLM?
- No. A managed AI gateway lets you select and swap models, so you keep pace as the AI ecosystem changes.
- How is this different from a general coding assistant like GitHub Copilot?
- General-purpose tools rarely understand a project deeply enough to get past high-level answers. AI Code Assistant learns the whole internal project, so it gives concrete, code-level answers that point to the actual components, endpoints, and tables.
- Does it support languages and environments beyond GitLab?
- A GitLab Duo hybrid setup extends coverage across a wide range of programming languages and environments.
After Deployment
We stay with you after the rollout
It doesn't end at the build. Training that lands the capability inside your team, and technical support that keeps it running steadily.
Let's evaluate it against your codebase
We design the rollout together, fitted to your repositories and development environment.