# How to Configure Custom OpenAI-Compatible API Endpoints for AI Summaries in Meetily

> Learn to configure custom OpenAI-compatible API endpoints for AI summaries in Meetily. Store your endpoint and API key in IndexedDB for seamless integration.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-07-31

---

**Meetily routes meeting summary requests to any OpenAI-compatible server by storing your custom endpoint URL and optional API key in IndexedDB via the ConfigService, then utilizing these credentials in the `useSummaryGeneration` hook to send standard chat completion requests.**

Meetily, the open-source meeting transcription platform from Zackriya-Solutions, decouples its frontend from specific LLM providers by implementing the OpenAI API contract. When you configure custom OpenAI-compatible API endpoints for AI summaries, you can direct summary generation to local Ollama instances, private LiteLLM proxies, or third-party providers like Groq without modifying the core application code.

## Architecture Overview for Custom LLM Integration

Meetily’s frontend architecture separates configuration management from request execution through three distinct layers. The **Settings UI** ([`frontend/src/components/Settings/ModelConfig.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/components/Settings/ModelConfig.tsx)) captures user input, the **ConfigService** ([`frontend/src/services/configService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/configService.ts)) persists values to IndexedDB via `storageService`, and the **summary generation hook** ([`frontend/src/hooks/meeting-details/useSummaryGeneration.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/hooks/meeting-details/useSummaryGeneration.ts)) retrieves these settings to construct authenticated HTTP requests.

This design allows runtime swapping of LLM backends. Because the request payload adheres strictly to the OpenAI chat completions schema—containing `model`, `messages`, `temperature`, and other standard parameters—any server implementing the `/v1/chat/completions` route can process Meetily’s summary requests.

## Step-by-Step Configuration Guide

### Accessing the Model Settings Interface

Navigate to the application sidebar and select **Model & API**. This renders the [`ModelConfig.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/ModelConfig.tsx) component, which provides form inputs for custom endpoint configuration. The UI accepts values for both the endpoint URL and the optional authentication token.

### Entering Endpoint Credentials

Enter the **full HTTP URL** pointing to your server’s chat completions route. For local Ollama deployments, use `http://localhost:11434/v1/chat/completions`. For cloud providers or custom inference servers, provide the complete path to their OpenAI-compatible endpoint.

Supply an **API key** only if your server enforces authentication. Meetily transmits this value in the `Authorization: Bearer <apiKey>` header. Leave the field empty for open local servers that do not require authentication.

### Saving and Runtime Persistence

Clicking **Save** invokes `ConfigService.setSummarizerEndpoint(endpoint, apiKey?)`, which writes the `summarizerEndpoint` and `summarizerApiKey` values to IndexedDB through `storageService`. These settings immediately become available to the summary generation workflow without requiring an application restart.

## Technical Implementation Details

### Configuration Service Layer

The [`frontend/src/services/configService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/configService.ts) file exports methods that abstract IndexedDB operations. When a user saves settings, `setSummarizerEndpoint` serializes the parameters and stores them as persistent configuration values. The complementary method `getSummarizerConfig()` retrieves these values asynchronously for use in API calls.

```typescript
// Storing configuration values
await ConfigService.setSummarizerEndpoint(
  'http://my-local-ollama:11434/v1/chat/completions',
  '' // No API key required for local Ollama
);

// Retrieving configuration for debugging
const { endpoint, apiKey } = await ConfigService.getSummarizerConfig();
console.log('Endpoint:', endpoint, 'Key present:', !!apiKey);

```

### Summary Generation Hook

The [`frontend/src/hooks/meeting-details/useSummaryGeneration.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/hooks/meeting-details/useSummaryGeneration.ts) hook orchestrates the actual API communication. It queries `ConfigService.getSummarizerConfig()` to obtain the current endpoint and credentials, then constructs a standard OpenAI chat completion payload containing the meeting transcript.

```typescript
// Constructing the OpenAI-compatible payload
const payload = {
  model: selectedModel,               // e.g., "llama3" or "gpt-4"
  messages: [{ role: 'user', content: transcriptText }],
  temperature: 0.7
};

// Executing the request with dynamic configuration
const response = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    ...(apiKey && { Authorization: `Bearer ${apiKey}` })
  },
  body: JSON.stringify(payload)
});

const result = await response.json();
return result.choices[0].message.content; // Rendered as meeting summary

```

### Request Format and Authentication

Meetily sends `POST` requests with `Content-Type: application/json` headers. When `apiKey` exists in configuration, the hook injects an `Authorization: Bearer <token>` header. The request body follows the OpenAI chat completions specification exactly, ensuring compatibility with any server adhering to that contract regardless of the underlying model architecture.

## Summary

- **Flexible Backend Support**: Meetily accepts any OpenAI-compatible endpoint, enabling local Ollama instances, cloud APIs, or custom inference servers.
- **Persistent Configuration**: Endpoint URLs and API keys store in browser IndexedDB via `ConfigService`, surviving page refreshes and browser sessions.
- **Standardized Protocol**: The `useSummaryGeneration` hook implements the OpenAI chat completions schema, requiring no code changes when swapping providers.
- **Optional Authentication**: API keys are only transmitted when explicitly provided, supporting both authenticated and open local deployments.
- **Runtime Configuration**: Changes take effect immediately for subsequent summary requests without application redeployment.

## Frequently Asked Questions

### What URL format should I use for Ollama endpoints?

Use the full path to the OpenAI-compatible route, typically `http://localhost:11434/v1/chat/completions`. Ollama exposes this endpoint when running with OpenAI compatibility enabled, allowing Meetily to interact with it as if it were a standard OpenAI server.

### Is an API key required for local LLM servers?

No. Local servers like Ollama or unsecured LiteLLM instances often run without authentication. Leave the API key field blank in the Model & API settings; Meetily will omit the `Authorization` header entirely when the key value is empty or undefined.

### Where does Meetily store my API credentials?

Credentials persist in the browser’s **IndexedDB** through the `storageService` layer. The `ConfigService` class in [`frontend/src/services/configService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/configService.ts) manages encryption-at-rest and retrieval, ensuring your endpoint configuration remains available across sessions without exposing keys in localStorage or cookies.

### Can I switch between different endpoints dynamically?

Yes. Because `useSummaryGeneration` reads configuration via `ConfigService.getSummarizerConfig()` at execution time, changing the endpoint in Settings immediately affects the next summary generation request. You can alternate between local development servers and production APIs without restarting the Meetily application.