Cliente API de Ollama para Delphi

15 de abril de 2026 · Componentes

Ollama facilita la ejecución local de grandes modelos de lenguaje en tu propio hardware — sin dependencia de la nube, sin costes de API y con total privacidad de los datos. Para los desarrolladores de Delphi que quieran integrar capacidades de IA local en sus aplicaciones, sgcWebSockets ofrece TsgcHTTP_API_Ollama — un componente nativo que encapsula toda la API de Ollama con un código Delphi limpio y con tipado seguro.

Tanto si necesitas mantener los datos sensibles on-premises, construir funcionalidades de IA que funcionen sin conexión, gestionar tu propia librería de modelos o generar embeddings para búsqueda vectorial local, este componente te da acceso directo a todas las funcionalidades de Ollama. Sin cuentas en la nube. Sin cuotas recurrentes de API. Simplemente añade el componente, apúntalo a tu instancia de Ollama y empieza a construir.

Cobertura completa de la API

Todas las funcionalidades principales de la API de Ollama están soportadas de serie.

Chat Completions Envía mensajes con system prompts, recibe respuestas de forma síncrona o por streaming. Control total sobre temperature, top-p y secuencias de parada.	Streaming en tiempo real Recibe las respuestas token a token mediante Server-Sent Events. Construye UIs responsivas con modelos ejecutados localmente.	Gestión de modelos Descarga modelos, consulta sus detalles, lista las etiquetas y elimina modelos de forma programática. Gestión completa del ciclo de vida desde código Delphi.
Embeddings Genera embeddings vectoriales localmente. Impulsa búsqueda semántica, clustering y clasificación sin enviar datos a la nube.	Autoalojado / Host configurable Conéctate a cualquier instancia de Ollama mediante una URL de host configurable. Ejecuta en local, en un servidor LAN o en una nube privada.	Reintentos y logging integrados Reintentos automáticos ante fallos transitorios con intentos e intervalos de espera configurables. Logging completo de petición/respuesta para depuración.

Primeros pasos

Integra Ollama en tu proyecto Delphi en menos de un minuto. Añade el componente, configura el host y envía tu primer mensaje.

// Create the component and configure the host
var
  Ollama: TsgcHTTP_API_Ollama;
  vResponse: string;
begin
  Ollama := TsgcHTTP_API_Ollama.Create(nil);
  Try
    Ollama.OllamaOptions.Host := 'http://localhost:11434';
    // Send a simple message to a local model
    vResponse := Ollama._CreateMessage(
      'llama3', 'Hello, Ollama!');
    ShowMessage(vResponse);
  Finally
    Ollama.Free;
  End;
end;

No requiere API key. Al conectarte a una instancia local de Ollama, no se necesita autenticación. Para despliegues remotos o asegurados, puedes establecer opcionalmente una API key mediante OllamaOptions.ApiKey.

Chat Completions y streaming

La API de Chat Completions funciona con cualquier modelo que hayas descargado en tu instancia de Ollama. Envía texto con system prompts opcionales y recibe las respuestas de forma síncrona o por streaming en tiempo real.

System Prompts

Controla el comportamiento del modelo proporcionando un system prompt que establezca el contexto, la personalidad o las restricciones de la conversación.

vResponse := Ollama._CreateMessageWithSystem(
  'llama3',
  'You are a helpful assistant that responds in Spanish.',
  'What is the capital of France?');
// Returns: "La capital de Francia es París."

Streaming en tiempo real

Para interfaces de usuario responsivas, recibe la respuesta del modelo token a token mediante Server-Sent Events.

// Enable streaming via SSE
Ollama.OnHTTPAPISSE := OnSSEEvent;
Ollama._CreateMessageStream('llama3',
  'Write a short poem about Delphi programming.');
procedure TForm1.OnSSEEvent(Sender: TObject;
  const aEvent, aData: string; var Cancel: Boolean);
begin
  // aData: JSON payload with generated content
  Memo1.Lines.Add(aData);
end;

API tipada avanzada

Para tener control total sobre los parámetros de la petición — temperature, top-p, secuencias de parada, max tokens — usa las clases tipadas de petición y respuesta.

var
  oRequest: TsgcOllamaClass_Request_ChatCompletion;
  oMessage: TsgcOllamaClass_Request_Message;
  oResponse: TsgcOllamaClass_Response_ChatCompletion;
begin
  oRequest := TsgcOllamaClass_Request_ChatCompletion.Create;
  Try
    oRequest.Model := 'llama3';
    oRequest.MaxTokens := 2048;
    oRequest.Temperature := 0.7;
    oMessage := TsgcOllamaClass_Request_Message.Create;
    oMessage.Role := 'user';
    oMessage.Content := 'Explain quantum computing in simple terms.';
    oRequest.Messages.Add(oMessage);
    oResponse := Ollama.CreateMessage(oRequest);
    Try
      if Length(oResponse.Choices) > 0 then
        ShowMessage(oResponse.Choices[0].MessageContent);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Gestión de modelos

Gestiona toda tu biblioteca local de modelos desde código Delphi. Descarga nuevos modelos, inspecciona sus detalles, lista las etiquetas disponibles y elimina los modelos que ya no necesitas — todo de forma programática.

Descargar un modelo

// Download a model from the Ollama registry
Ollama._PullModel('llama3');

Mostrar detalles del modelo

// Get detailed information about a model
vDetails := Ollama._ShowModel('llama3');
ShowMessage(vDetails);

Listar modelos y etiquetas

// List all models via OpenAI-compatible endpoint
vModels := Ollama._GetModels;
// List model tags with detailed metadata (name, size, digest)
vTags := Ollama._GetTags;
// Typed API: access tag properties directly
var
  oTags: TsgcOllamaClass_Response_Tags;
  i: Integer;
begin
  oTags := Ollama.GetTags;
  Try
    for i := 0 to Length(oTags.Models) - 1 do
      Memo1.Lines.Add(Format('%s (%d bytes)',
        [oTags.Models[i].Name, oTags.Models[i].Size]));
  Finally
    oTags.Free;
  End;
end;

Eliminar un modelo

// Remove a model from the local system
Ollama._DeleteModel('old-model:latest');

Embeddings

Genera embeddings vectoriales localmente usando cualquier modelo con capacidad de embeddings. Los embeddings impulsan búsqueda semántica, clustering de documentos y clasificación — todo sin enviar datos a servidores externos.

// Generate embeddings locally
var
  vEmbedding: string;
begin
  vEmbedding := Ollama._CreateEmbeddings(
    'nomic-embed-text',
    'Delphi is a powerful programming language.');
  ShowMessage(vEmbedding);
end;

Para un control total, usa la API tipada para acceder a los valores brutos del embedding.

var
  oResponse: TsgcOllamaClass_Response_Embeddings;
  i: Integer;
begin
  oResponse := Ollama.CreateEmbeddings(
    'nomic-embed-text',
    'Delphi is a powerful programming language.');
  Try
    for i := 0 to oResponse.EmbeddingCount - 1 do
      Memo1.Lines.Add(FloatToStr(oResponse.GetEmbeddingValue(i)));
  Finally
    oResponse.Free;
  End;
end;

Privacidad de datos. Con Ollama, tus datos nunca salen de tu red. Esto lo hace ideal para industrias reguladas (sanidad, finanzas, administración pública) donde la residencia de datos y la privacidad son requisitos críticos.

Configuración y opciones

Ajusta con precisión el comportamiento del componente mediante completas opciones de configuración.

Propiedad	Descripción
`OllamaOptions.Host`	URL del servidor Ollama (p. ej., http://localhost:11434)
`OllamaOptions.ApiKey`	API key opcional para despliegues asegurados
`HttpOptions.ReadTimeout`	Timeout de lectura HTTP en milisegundos (por defecto: 60000)
`LogOptions.Enabled`	Habilita el logging de peticiones/respuestas
`RetryOptions.Enabled`	Reintentos automáticos en fallos transitorios
`RetryOptions.Retries`	Número máximo de intentos de reintento (por defecto: 3)
`RetryOptions.Wait`	Tiempo de espera entre reintentos en milisegundos (por defecto: 3000)

Modelos soportados

Ollama admite cientos de modelos de código abierto. Aquí tienes algunas opciones populares:

Modelo	Parámetros	Mejor para
`llama3`	8B / 70B	Chat de propósito general, razonamiento
`mistral`	7B	Generación de texto rápida y eficiente
`codellama`	7B / 13B / 34B	Generación y análisis de código
`nomic-embed-text`	137M	Embeddings de texto, búsqueda semántica

Coste cero, control total. Ejecuta modelos de IA en tu propio hardware sin cargos por token. Combinado con la lógica de reintentos y el logging integrados de sgcWebSockets, obtienes una integración de IA local lista para producción en Delphi.