# How to Use Local AI Models with DBX's AI SQL Assistant: Ollama & OpenAI-Compatible Setup

> Use local AI models with DBX's AI SQL Assistant! Discover how to integrate Ollama and OpenAI-compatible endpoints for seamless local deployments. Get started today.

- Repository: [skyler/dbx](https://github.com/t8y2/dbx)
- Tags: how-to-guide
- Published: 2026-07-06

---

**Yes, DBX's AI SQL Assistant fully supports local AI models via Ollama and any OpenAI-compatible API endpoint, automatically rewriting endpoints to the chat completion URL and disabling API-key authentication for local deployments.**

The **t8y2/dbx** repository provides a privacy-first database explorer with an integrated AI SQL Assistant that can run entirely on your local machine. By implementing an OpenAI-compatible interface, DBX allows you to use **local AI models with DBX's AI SQL Assistant** through Ollama or other self-hosted servers, ensuring sensitive database schemas and queries never leave your environment.

## How Local AI Integration Works in DBX

DBX uses a dual-layer architecture to handle AI provider configuration. The system determines which provider to use from the **AI settings** stored in the desktop application, then processes requests through a core Rust module that handles endpoint resolution and HTTP client construction.

### OpenAI-Compatible API Foundation

At the core of DBX's local AI support is the OpenAI chat-completion schema implementation found in [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs). This module validates configurations, resolves endpoints, and builds the HTTP client for all providers. Because DBX treats local endpoints as OpenAI-compatible, you can point the assistant at any self-hosted server—including **vLLM**, **LMStudio**, or custom implementations—by providing the appropriate URL in the settings.

### Ollama-Specific Endpoint Transformation

When the provider is set to `ollama`, DBX automatically applies specific transformations in [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs):

- **Endpoint Rewriting**: The base URL (e.g., `http://localhost:11434/v1`) is automatically rewritten to the chat completion endpoint (`/v1/chat/completions`)
- **Authentication Disabled**: The `requiresApiKey` flag is set to `false`, allowing requests without API keys since Ollama does not require authentication for local access
- **Safety Checks Maintained**: All returned SQL still passes through DBX's built-in safety validation before execution

## Setting Up Ollama for DBX's AI SQL Assistant

Configure your local Ollama instance in four steps:

1. **Install Ollama** and pull your preferred model (e.g., `llama3.1`)
2. **Add the AI provider** in DBX's Settings → AI SQL Assistant UI pointing to `http://localhost:11434/v1`
3. **Select the Ollama provider** from the dropdown—DBX automatically detects the localhost endpoint and sets `requiresApiKey: false`
4. **Use the assistant normally**—your prompts route to the local model, and the returned SQL undergoes DBX's standard safety checks before injection into the editor

The default configuration stored in [`apps/desktop/src/stores/settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/apps/desktop/src/stores/settingsStore.ts) provides built-in presets for Ollama, automatically selecting the correct provider when it detects `localhost:11434` in the endpoint URL.

## Configuring Alternative Local Models (vLLM, LMStudio)

For local AI servers other than Ollama, use the **OpenAI-compatible** provider entry:

- Enter your self-hosted server URL (e.g., `http://localhost:8000/v1` for vLLM)
- Specify the model name as defined by your local server
- Provide an API key if your local server requires authentication (most local deployments do not)

No code changes are required; DBX's normalization logic in [`apps/desktop/src/stores/settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/apps/desktop/src/stores/settingsStore.ts) handles the configuration formatting automatically.

## Technical Deep Dive: Configuration and Normalization

### Frontend Store Logic in [`settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/settingsStore.ts)

The frontend store located at [`apps/desktop/src/stores/settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/apps/desktop/src/stores/settingsStore.ts) defines the built-in AI provider presets, including the Ollama defaults. This TypeScript module exports a `normalizeAiConfig` function that ensures user-supplied configurations conform to the expected schema before transmission to the Rust core.

When you save an Ollama configuration, the store automatically sets:

```json
{
  "provider": "ollama",
  "endpoint": "http://localhost:11434/v1",
  "model": "llama3.1",
  "apiStyle": "completions",
  "requiresApiKey": false
}

```

### Core Rust Implementation in [`ai.rs`](https://github.com/t8y2/dbx/blob/main/ai.rs)

The Rust module at [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs) contains the provider-agnostic HTTP client logic. For Ollama endpoints, this module performs the final URL transformation to append `/chat/completions` to the base path, ensuring compatibility with the OpenAI API specification while maintaining the local privacy benefits.

## Practical Code Examples

### Normalizing a Local AI Configuration

Use the store's normalization routine to prepare your config exactly as DBX processes it internally:

```typescript
import { normalizeAiConfig } from '@/stores/settingsStore';

const rawConfig = {
  provider: 'ollama',
  endpoint: 'http://localhost:11434/v1',
  model: 'llama3.1',
};
const cfg = normalizeAiConfig(rawConfig);
// cfg.endpoint → "http://localhost:11434/v1/chat/completions"

```

This transformation matches the logic found in [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs) that routes requests to the correct chat completion endpoint.

### Sending Queries to Your Local Model

Once configured, invoke the assistant from the desktop UI:

```typescript
await dbxAiClient.ask({
  prompt: "Show me the top 10 customers by revenue last month",
  model: cfg.model,               // "llama3.1"
  endpoint: cfg.endpoint,         // "http://localhost:11434/v1/chat/completions"
});

```

The response is parsed, safety-checked against DBX's query validation rules, and injected into the SQL editor as executable code.

## Summary

- **DBX's AI SQL Assistant** supports local AI models through any OpenAI-compatible API endpoint, with first-class support for Ollama as documented in [`docs/public/llms.txt`](https://github.com/t8y2/dbx/blob/main/docs/public/llms.txt) and the project [`README.md`](https://github.com/t8y2/dbx/blob/main/README.md).
- **Automatic Configuration**: When using Ollama, DBX automatically rewrites endpoints to `/v1/chat/completions` and disables API-key requirements via logic in [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs).
- **Frontend Integration**: The [`apps/desktop/src/stores/settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/apps/desktop/src/stores/settingsStore.ts) module provides presets and normalization for local providers.
- **Security**: All generated SQL undergoes DBX's built-in safety checks regardless of whether the model is local or cloud-hosted.
- **Flexibility**: You can switch between cloud providers (Claude, OpenAI) and local models (Ollama, vLLM, LMStudio) without code changes by adjusting the Settings UI configuration.

## Frequently Asked Questions

### Does DBX's AI SQL Assistant support models other than Ollama?

Yes. While Ollama receives special handling for endpoint normalization, DBX supports any local model server implementing the OpenAI chat-completion schema. This includes **vLLM**, **LMStudio**, **LocalAI**, and custom HTTP servers. Configure these through the "OpenAI-compatible" provider entry with your local URL.

### Is an API key required for local AI models in DBX?

No. When you select the Ollama provider or configure a localhost endpoint, DBX automatically sets `requiresApiKey: false` in the configuration. The core Rust logic in [`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs) skips authentication headers for these endpoints, though you can manually specify a key if your local server requires custom authentication.

### Can I switch between cloud and local AI models in DBX?

Yes. DBX stores multiple AI provider configurations in the desktop app settings. You can create entries for both cloud providers (OpenAI, Anthropic) and local models (Ollama), then switch between them using the provider selector in the AI SQL Assistant interface without restarting the application.

### Where does DBX store the AI provider configuration?

Configuration persists in the desktop application's internal store managed by [`apps/desktop/src/stores/settingsStore.ts`](https://github.com/t8y2/dbx/blob/main/apps/desktop/src/stores/settingsStore.ts). This includes provider type, endpoint URLs, model names, and authentication requirements. The store normalizes these settings before passing them to the Rust core ([`crates/dbx-core/src/ai.rs`](https://github.com/t8y2/dbx/blob/main/crates/dbx-core/src/ai.rs)) for request execution.