Cliente Gemini API para Delphi

14 de abril de 2026 · Componentes

Google Gemini es una de las familias de modelos de IA multimodal más potentes disponibles hoy en día, destacando en generación de texto, comprensión de imágenes, salidas estructuradas y function calling en una amplia variedad de casos de uso. Para los desarrolladores Delphi que quieran integrar Gemini en sus aplicaciones, sgcWebSockets proporciona TsgcHTTP_API_Gemini — un componente nativo y completo que envuelve toda la superficie de la API de Google Gemini.

Ya estés construyendo asistentes conversacionales, generando datos estructurados, procesando imágenes, creando embeddings para búsqueda semántica u orquestando workflows aumentados con herramientas, este componente te da acceso directo a cada funcionalidad de Gemini a través de código Delphi limpio y con tipos seguros. Sin boilerplate REST. Sin pelearse con JSON. Sólo coloca el componente, configura tu API key y empieza a construir.

Cobertura completa de la API

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

Generación de contenido Genera texto a partir de prompts con instrucciones de sistema opcionales. Afina la salida con temperature, top-p, top-k y stop sequences.	Streaming en tiempo real Recibe las respuestas token a token usando Server-Sent Events. Construye interfaces responsivas que muestren las respuestas a medida que se generan.	Visión Analiza imágenes enviando datos codificados en base64 junto con un prompt de texto. Gemini describe, interpreta y razona sobre contenido visual.
Salida JSON estructurada Obliga a Gemini a devolver JSON válido conforme a tu schema. Configura un MIME type y schema de respuesta para garantizar resultados parseables.	Function calling Define funciones a medida con JSON Schema. Gemini decide cuándo invocarlas, habilitando workflows agénticos de varios pasos.	Embeddings Genera embeddings vectoriales para texto. Alimenta búsqueda semántica, clustering, clasificación y sistemas de recomendación.
Conteo de tokens Cuenta tokens antes de enviar peticiones. Estima costes con precisión y gestiona el presupuesto de ventana de contexto.	Gestión de modelos Lista todos los modelos Gemini disponibles o recupera detalles de uno concreto, incluidos los límites de tokens de entrada/salida.	Retry y logging integrados Retry automático ante fallos transitorios con intentos e intervalos de espera configurables. Logging completo de petición/respuesta para depurar.

Primeros pasos

Integra Google Gemini en tu proyecto Delphi en menos de un minuto. Coloca el componente, configura tu API key y envía tu primer mensaje.

// Create the component and configure the API key
var
  Gemini: TsgcHTTP_API_Gemini;
  vResponse: string;
begin
  Gemini := TsgcHTTP_API_Gemini.Create(nil);
  Try
    Gemini.GeminiOptions.ApiKey := 'YOUR_API_KEY';
    // Send a simple message to Gemini
    vResponse := Gemini._CreateContent(
      'gemini-2.5-flash', 'Hello, Gemini!');
    ShowMessage(vResponse);
  Finally
    Gemini.Free;
  End;
end;

Dos estilos de API. Cada funcionalidad ofrece métodos de conveniencia (basados en strings, código mínimo) y clases de petición/respuesta tipadas (control total, seguridad de tipos). Elige el enfoque que mejor se adapte a tu caso de uso.

Generación de contenido y streaming

La API GenerateContent es la base de toda interacción con Gemini. Envía texto con instrucciones de sistema opcionales y recibe respuestas síncronamente o en streaming en tiempo real.

Instrucciones de sistema

Controla el comportamiento de Gemini proporcionando una instrucción de sistema que establezca el contexto, la personalidad o las restricciones de la conversación.

vResponse := Gemini._CreateContentWithSystem(
  'gemini-2.5-flash',
  '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 de Gemini token a token usando Server-Sent Events. Asigna el manejador de evento OnHTTPAPISSE y llama a _CreateContentStream.

// Enable streaming via SSE
Gemini.OnHTTPAPISSE := OnSSEEvent;
Gemini._CreateContentStream('gemini-2.5-flash',
  'Tell me a story about a brave explorer.');
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 control total sobre los parámetros de la petición — temperature, top-p, top-k, stop sequences, max output tokens — usa las clases tipadas de petición y respuesta.

var
  oRequest: TsgcGeminiClass_Request_GenerateContent;
  oResponse: TsgcGeminiClass_Response_GenerateContent;
begin
  oRequest := TsgcGeminiClass_Request_GenerateContent.Create;
  Try
    oRequest.Model := 'gemini-2.5-flash';
    oRequest.SystemInstruction := 'You are a helpful assistant.';
    oRequest.MaxOutputTokens := 2048;
    oRequest.Temperature := 0.7;
    oRequest.TopP := 0.9;
    oRequest.TopK := 40;
    oRequest.Contents.Add('user', 'Explain quantum computing in simple terms.');
    oResponse := Gemini.CreateContent(oRequest);
    Try
      if Length(oResponse.Candidates) > 0 then
        ShowMessage(oResponse.Candidates[0].Parts[0].Text);
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Visión — comprensión de imágenes

Gemini es nativamente multimodal. Envía fotografías, capturas de pantalla, diagramas o gráficos junto con un prompt de texto y recibe descripciones detalladas, extracción de datos o Q&A visual.

// Load an image and ask Gemini to describe it
var
  vBase64: string;
begin
  vBase64 := sgcBase64Encode(LoadFileToBytes('product-photo.png'));
  ShowMessage(Gemini._CreateVisionContent(
    'gemini-2.5-flash',
    'Describe this product image for an e-commerce listing.',
    vBase64, 'image/png'));
end;

Caso de uso. Automatiza inspecciones de calidad, genera texto alternativo para accesibilidad, extrae datos de gráficos o construye funciones de búsqueda visual — todo desde código Delphi nativo.

Salida JSON estructurada

Garantiza que Gemini devuelva JSON válido y parseable conforme a tu schema exacto. Configura un MIME type y schema de respuesta para eliminar el post-procesado — la respuesta está lista para deserializarse directamente en tus records de Delphi.

var
  vSchema, vResponse: string;
begin
  vSchema :=
    '{"type":"object","properties":{"name":{"type":"string"},' +
    '"age":{"type":"integer"}},"required":["name","age"]}';
  vResponse := Gemini._CreateContentJSON(
    'gemini-2.5-flash',
    'Extract the name and age: John is 30 years old.',
    vSchema);
  // Returns: {"name": "John", "age": 30}
end;

Aplicación del schema. Configurando ResponseMimeType a 'application/json' y proporcionando un ResponseSchema, Gemini garantiza una salida estructuralmente válida en todo momento.

Function calling

Define funciones a medida con JSON Schema y Gemini decidirá cuándo y cómo invocarlas. Ésta es la base para construir workflows agénticos de varios pasos que conecten la IA con tu lógica de negocio.

var
  oRequest: TsgcGeminiClass_Request_GenerateContent;
  oFunc: TsgcGeminiClass_Request_FunctionDeclaration;
  oResponse: TsgcGeminiClass_Response_GenerateContent;
begin
  oRequest := TsgcGeminiClass_Request_GenerateContent.Create;
  Try
    oRequest.Model := 'gemini-2.5-flash';
    // Define a function
    oFunc := TsgcGeminiClass_Request_FunctionDeclaration.Create;
    oFunc.Name := 'get_weather';
    oFunc.Description := 'Get the current weather in a location';
    oFunc.Parameters :=
      '{"type":"object","properties":{"location":{"type":"string"}}}';
    oRequest.FunctionDeclarations.Add(oFunc);
    oRequest.Contents.Add('user',
      'What is the weather in Madrid?');
    oResponse := Gemini.CreateContent(oRequest);
    Try
      // Check if Gemini wants to call a function
      if oResponse.Candidates[0].Parts[0].FunctionCallName  '' then
      begin
        ShowMessage('Function: ' + oResponse.Candidates[0].Parts[0].FunctionCallName);
        ShowMessage('Args: ' + oResponse.Candidates[0].Parts[0].FunctionCallArgs);
      end;
    Finally
      oResponse.Free;
    End;
  Finally
    oRequest.Free;
  End;
end;

Embeddings

Genera embeddings vectoriales de alta calidad para texto. Los embeddings alimentan búsqueda semántica, clustering de documentos, motores de recomendación y tareas de clasificación.

// Generate embeddings for a text
var
  vEmbedding: string;
begin
  vEmbedding := Gemini._EmbedContent(
    'text-embedding-004',
    'Delphi is a powerful programming language.');
  ShowMessage(vEmbedding);
end;

Para control total, usa la API tipada para acceder al array de valores brutos del embedding.

var
  oResponse: TsgcGeminiClass_Response_Embedding;
  i: Integer;
begin
  oResponse := Gemini.EmbedContent(
    'text-embedding-004',
    'Delphi is a powerful programming language.');
  Try
    for i := 0 to Length(oResponse.Values) - 1 do
      Memo1.Lines.Add(FloatToStr(oResponse.Values[i]));
  Finally
    oResponse.Free;
  End;
end;

Conteo de tokens

Estima costes y gestiona el presupuesto de ventana de contexto con precisión antes de enviar peticiones.

var
  vTokens: string;
begin
  vTokens := Gemini._CountTokens(
    'gemini-2.5-flash',
    'How many tokens does this message consume?');
  ShowMessage(vTokens);
end;

Gestión de modelos

Consulta los modelos Gemini disponibles por código. Lista todos los modelos o recupera detalles de un modelo concreto, incluido nombre, descripción y límites de tokens.

// List all available Gemini models
vModels := Gemini._GetModels;
// Get details for a specific model
vModel := Gemini._GetModel('gemini-2.5-flash');
// Typed API: access model properties directly
var
  oModel: TsgcGeminiClass_Response_Model;
begin
  oModel := Gemini.GetModel('gemini-2.5-flash');
  Try
    ShowMessage('Name: ' + oModel.DisplayName);
    ShowMessage('Input limit: ' + IntToStr(oModel.InputTokenLimit));
    ShowMessage('Output limit: ' + IntToStr(oModel.OutputTokenLimit));
  Finally
    oModel.Free;
  End;
end;

Configuración y opciones

Afina el comportamiento del componente con opciones de configuración completas.

Propiedad	Descripción
`GeminiOptions.ApiKey`	tu API key de Google Gemini (obligatorio)
`HttpOptions.ReadTimeout`	timeout de lectura HTTP en milisegundos (por defecto: 60000)
`LogOptions.Enabled`	habilita el logging de petición/respuesta
`LogOptions.FileName`	ruta del archivo de log para capturar peticiones/respuestas
`RetryOptions.Enabled`	retry automático ante fallos transitorios (429, 503)
`RetryOptions.Retries`	número máximo de intentos de retry (por defecto: 3)
`RetryOptions.Wait`	tiempo de espera entre retries en milisegundos (por defecto: 3000)

Parámetros de la petición

Parámetro	Descripción
`Temperature`	temperatura de sampling (0.0–2.0). Valores más bajos = más determinista.
`TopP`	nucleus sampling (0.0–1.0). Controla el corte de probabilidad acumulada.
`TopK`	top-K sampling. Limita la selección de tokens a los K candidatos principales.
`MaxOutputTokens`	número máximo de tokens en la respuesta (por defecto: 4096).
`StopSequences`	secuencias personalizadas que detienen la generación al encontrarse.
`ResponseMimeType`	formato de salida: 'application/json' para JSON, 'text/plain' para texto.
`ToolChoice`	controla cómo el modelo selecciona las funciones a llamar.