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

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) captures user input, the ConfigService (frontend/src/services/configService.ts) persists values to IndexedDB via storageService, and the summary generation hook (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 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 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.

// 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 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.

// 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}