Además de los comandos interactivos, Ollama proporciona un API para poder interactuar con los LLMs. Este API es útil sobre todo en casos en los que se quiera realizar una integración con otras aplicaciones (como por ejemplo desde Spring AI), puesto que lo único que habría que hacer es realizar una llamada al endpoint Rest correspondiente.

Por defecto, el API está expuesta en el puerto 11434 (http://localhost:11434 o http://127.0.0.1:11434), aunque es configurable. Los endpoints que expone el API son:

• /api/generate: método POST. Endpoint para obtener respuestas del LLM con un único prompt que no sea con una secuencia de pregunta-respuesta. Óptimo para tareas como predicción de textos o traducción.
• /api/chat: método POST. Endpoint para interacción pregunta-respuesta conversacional.
• /api/embeddings: método POST. Genera embeddings (representaciones vectoriales numéricas) del input.
• /api/tags: método GET. Equivalente al comando interactivo ollama list con el que se muestra un listado de modelos existentes en el sistema.
• /api/show: método POST. Equivalente al comando interactivo ollama show con el que se obtiene información sobre un modelo concreto como parámetros, plantillas, licencias, etc.
• /api/delete: método DELETE. Equivalente al comando interactivo ollama rm para eliminar un modelo del sistema local.
• /api/pull: método POST. Equivalente al comando interactivo ollama pull para descargar un modelo desde el repositorio remoto al sistema local.
• /api/create: método POST. Equivalente al comando interactivo ollama create con el que se crea un nuevo modelo personalizado a partir de un Modelfile.
• /api/copy: método POST. Equivalente al comando interactivo ollama cp para copiar un modelo en el sistema local.
• /api/push: método POST. Endpoint para subir un modelo al repositorio remoto.

 Peticiones básicas simples

Curl básico

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Why is the sky blue?"
}'

Curl para Windows

curl --location --request POST "https://api.elhacker.net/api/chat" ^
--header "Content-Type: application/json" ^
--data-raw "{    \"model\": \"gemma3:27b-it-fp16\",    \"messages\": [        {            \"role\": \"user\",            \"content\": \"why is the sky blue?\"        }    ]}" 

En PowerShell para Windows

(Invoke-WebRequest -method POST -Body '{"model":"gemma3:27b-it-fp16", "prompt":"hola", "stream": false}' -uri https://api.elhacker.net/api/generate ).Content | ConvertFrom-json 

Otro ejemplo PowerShell para Windows

$headers = New-Object "System.Collections.Generic.Dictionary[[String],[String]]"
$headers.Add("Content-Type", "application/json")

$body = "{`n    `"model`": `"gemma3:27b-it-fp16`",`n    `"messages`": [`n        {`n            `"role`": `"user`",`n            `"content`": `"why is the sky blue?`"`n        }`n    ]`n}"

$response = Invoke-RestMethod 'https://api.elhacker.net/api/chat' -Method 'POST' -Headers $headers -Body $body
$response | ConvertTo-Json

En Python (ejemplo chat.py)

import requests, json

# Define the local Ollama API endpoint
url = "https://api.elhacker.net/api/generate"

# Send a prompt to the Gemma 3 model
payload = {
    "model": "gemma3:27b-it-fp16",
    "prompt": "Write a short story about space exploration."
}

# stream=True tells requests to read the response as a live data stream
response = requests.post(url, json=payload, stream=True)

# Ollama sends one JSON object per line as it generates text
for line in response.iter_lines():
    if line:
        data = json.loads(line.decode("utf-8"))
        # Each chunk has a "response" key containing part of the text
        if "response" in data:
            print(data["response"], end="", flush=True) 

Librería Ollama

pip install ollama

from ollama import chat

stream = chat(
    model='gemma3:27b-it-fp16',
    messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
    stream=True,
)

for chunk in stream:
  print(chunk['message']['content'], end='', flush=True) 

Javascript

    async function callStreamingAPI() {
      try {
        const response = await fetch('https://api.elhacker.net/api/generate', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            model: 'gemma3:27b-it-fp16',
            prompt: 'hola'
          })
        });

Explicación

• async function callStreamingAPI(): Define una función asíncrona para realizar la llamada a la API.
• fetch(): Envía una solicitud HTTP POST a la URL especificada con el Content-Type y el cuerpo indicados.
• JSON.stringify(): Convierte el objeto JavaScript en una cadena JSON para enviarla en el cuerpo de la solicitud. 

Streming la respuesta

        const reader = response.body.getReader();
        const decoder = new TextDecoder('utf-8');
        const outputElement = document.getElementById('output');

        let done = false;
        while (!done) {
          const { value, done: readerDone } = await reader.read();
          done = readerDone;

          if (value) {
            const chunk = decoder.decode(value, { stream: true });
            const parts = chunk.split('\n').filter(Boolean);

            parts.forEach(part => {
              try {
                const json = JSON.parse(part);
                outputElement.innerHTML += json.response;
              } catch (err) {
                console.error('Error parsing chunk:', err);
              }
            });
          }
        }
      } catch (error) {
        console.error('Error calling the API:', error);
      }
    }

Explicación

• response.body.getReader(): Accede a un ReadableStream desde la respuesta, lo que le permite leer los datos en fragmentos.
• new TextDecoder(“utf-8”): Decodifica los fragmentos de la respuesta desde un formato binario a texto legible.
• let done = false: Un indicador para controlar el bucle de lectura del flujo.
• while (!done): Repite el bucle hasta llegar al final del flujo.
• await reader.read(): Lee el siguiente fragmento del flujo. El resultado contiene value (el fragmento de datos) y done (un valor booleano que indica si el flujo ha finalizado).
• decoder.decode(value, { stream: true }): Decodifica el fragmento de datos binarios en una cadena UTF-8.
•  chunk.split(“\n”).filter(Boolean): Divide la cadena decodificada en partes JSON separadas basadas en saltos de línea y filtra las cadenas vacías.
•  JSON.parse(part): Analiza cada parte como JSON.
•  outputElement.innerHTML += json.response: Añade el campo de respuesta de cada objeto JSON al div de salida.
• catch (error): Detecta y registra cualquier error que se produzca durante la obtención o el procesamiento del flujo.

Test ejemplo navegador

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Streaming API Example</title>
</head>
<body>
  <h1>Streaming API Response</h1>
  <div id="output"></div>

  <script>
    async function callStreamingAPI() {
      input_user = prompt("Enter Text here : ")
      try {
        const response = await fetch('http://localhost:11434/api/generate', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            model: 'llama3.2',
            prompt: input_user
          })
        });

        // Read the response as a stream of text
        const reader = response.body.getReader();
        const decoder = new TextDecoder('utf-8');
        const outputElement = document.getElementById('output');

        let done = false;
        while (!done) {
          const { value, done: readerDone } = await reader.read();
          done = readerDone;

          if (value) {
            // Decode and split by newline to parse each JSON object
            const chunk = decoder.decode(value, { stream: true });
            const parts = chunk.split('\n').filter(Boolean);

            parts.forEach(part => {
              try {
                const json = JSON.parse(part);
                outputElement.innerHTML += json.response; // Append response text
              } catch (err) {
                console.error('Error parsing chunk:', err);
              }
            });
          }
        }
      } catch (error) {
        console.error('Error calling the API:', error);
      }
    }

    // Call the function when the script loads
    callStreamingAPI();
  </script>
</body>
</html>

En PHP

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
   CURLOPT_URL => 'http://localhost:11434/api/chat',
   CURLOPT_RETURNTRANSFER => true,
   CURLOPT_ENCODING => '',
   CURLOPT_MAXREDIRS => 10,
   CURLOPT_TIMEOUT => 0,
   CURLOPT_FOLLOWLOCATION => true,
   CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
   CURLOPT_CUSTOMREQUEST => 'POST',
   CURLOPT_POSTFIELDS =>'{
    "model": "llama3.2",
    "messages": [
        {
            "role": "user",
            "content": "Hello, please introduce yourself"
        }
    ],
    "stream": false
}',
   CURLOPT_HTTPHEADER => array(
      'Content-Type: application/json'
   ),
));

$response = curl_exec($curl);

curl_close($curl);
echo $response;

Resolución de problemas relacionados con CORS (opcional)

Acerca de la política CORS si se encuentra con este problema

Cuando se produce el error «El acceso a fetch en “http://localhost:11434/api/chat” desde el origen “null” ha sido bloqueado por la política CORS: la respuesta a la solicitud previa no supera la comprobación de control de acceso: No hay ningún encabezado «Access-Control-Allow-Origin» en el recurso solicitado», significa que el servidor no está configurado para permitir solicitudes de diferentes orígenes. Este problema se debe a la política de intercambio de recursos entre orígenes (CORS), que restringe las solicitudes de las páginas web a un dominio diferente al que sirve la página web.

Para solucionar este problema, puedes:

• 1.  Configurar el servidor para permitir CORS: asegúrese de que el servidor al que intenta acceder tiene el encabezado Access-Control-Allow-Origin configurado para permitir solicitudes desde el origen de su aplicación web (o utilice * para permitir todos los orígenes con fines de prueba).
•     Utilizar extensiones del navegador: si no tiene acceso para modificar el servidor o necesita una solución rápida con fines de desarrollo, utilice extensiones del navegador como Moesif Origin & CORS Changer o CORS Unblock. Estas extensiones pueden anular la política CORS predeterminada del navegador para permitir la solicitud.
•     Establezca el modo de solicitud en «no-cors»: aunque esto puede permitir que ciertas solicitudes eludan las comprobaciones CORS, tiene limitaciones, ya que solo recibirá respuestas opacas que no incluyen contenido. Esto no es ideal para la mayoría de los casos de uso que requieren la recuperación de datos.

Query api chat

curl https://api.elhacker.net/api/chat -d '{
  "model": "gemma3:27b-it-fp16",
  "stream": false,
  "messages": [
    {
      "role": "user",
      "content": "hola"
    }
  ]
}'

• message content

Query api generate

curl https://api.elhacker.net/api/generate -d '{
  "model": "gemma3:27b-it-fp16",
  "stream": false,
  "prompt": "hola"
}'

• response 

• https://github.com/ollama/ollama-python
• https://github.com/ollama/ollama-js