> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Gemini Imagine
> Generación de imagen/vídeo con Gemini
## Guía de Imagen
Imagen es una serie avanzada de modelos de IA para generación de imágenes desarrollada por Google, capaz de crear imágenes realistas de alta calidad a partir de prompts de texto. Esta guía te ayudará a entender cómo usar la API de Imagen para generar imágenes, incluida la configuración de parámetros, la selección de modelo y ejemplos de código.
Modelos disponibles:
* imagen-4.0-ultra-generate-001
* imagen-4.0-generate-001
* imagen-4.0-fast-generate-001
* imagen-4.0-fast-generate-preview-06-06
* imagen-3.0-generate-002
1. Actualmente, Imagen solo admite prompts en inglés. Al integrarlo, se recomienda añadir traducción automática para permitir que los usuarios lo usen sin barreras de idioma.
2. El rendimiento es inestable al renderizar grandes cantidades de texto. Se recomienda incluir solo palabras clave esenciales.
### Parámetros del modelo
Imagen actualmente solo admite prompts en inglés y ofrece los siguientes parámetros:
* **numberOfImages**: El número de imágenes a generar, en un rango de 1 a 4 (ambos incluidos). El valor predeterminado es 4.
* `imagen-4.0-ultra-generate-001` solo puede generar 1 imagen a la vez.
* **aspectRatio**: Cambia la relación de aspecto de las imágenes generadas. Los valores admitidos son "1:1", "3:4", "4:3", "9:16" y "16:9". El valor predeterminado es "1:1".
* **personGeneration**: Permite al modelo generar imágenes de personas. Admite los siguientes valores:
* "DONT\_ALLOW": Evita la generación de imágenes que contengan personas.
* "ALLOW\_ADULT": Genera imágenes de adultos pero no de niños. Este es el valor predeterminado.
### Precios de uso
El costo de utilizar la API de Imagen para generar imágenes:
* imagen-4-ultra: \$0.06/imagen
* imagen-4: \$0.04/imagen
* imagen-4-fast: \$0.02/imagen
* imagen-3: \$0.03/imagen
Ten en cuenta que cada llamada a la API puede generar 1-4 imágenes y se te facturará según el número real de imágenes generadas.
### Ejemplo de llamada a la API
A continuación, un ejemplo en Python para generar imágenes con Imagen 3.0:
```py Imagen theme={null}
import os
import time
from google import genai
from google.genai import types
from PIL import Image
from io import BytesIO
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
# Currently only supports English prompts, performance is poor with large amounts of text
response = client.models.generate_images(
model='imagen-4.0-fast-generate-001',
prompt='A minimalist logo for a LLM router market company on a solid white background. trident in a circle as the main symbol, with ONLY text \'InferEra\' below.',
config=types.GenerateImagesConfig(
number_of_images=1,
aspect_ratio="1:1", # supports "1:1", "9:16", "16:9", "3:4", or "4:3".
)
)
script_dir = os.path.dirname(os.path.abspath(__file__))
output_dir = os.path.join(script_dir, "output")
os.makedirs(output_dir, exist_ok=True)
# Generate timestamp as filename prefix to avoid filename conflicts
timestamp = int(time.time())
# Save and display the generated images
if response and hasattr(response, 'generated_images') and response.generated_images:
for i, generated_image in enumerate(response.generated_images):
try:
image = Image.open(BytesIO(generated_image.image.image_bytes))
image.show()
file_name = f"imagen3_{timestamp}_{i+1}.png"
file_path = os.path.join(output_dir, file_name)
image.save(file_path)
print(f"Image saved to: {file_path}")
except Exception as e:
print(f"Error processing image {i+1}: {e}")
else:
print("Error: No valid image response received")
print(f"Response type: {type(response)}")
if response:
print(f"Response attributes: {dir(response)}")
if hasattr(response, 'generated_images'):
print(f"generated_images value: {response.generated_images}")
else:
print("Response is empty, please check API key and network connection")
```
### Consejos para prompts
Crear prompts eficaces es fundamental para obtener las imágenes deseadas:
* Usa descripciones detalladas que incluyan sujeto, estilo, iluminación, ángulo, etc.
* Especifica estilos artísticos (como cinematográfico, fotorrealista, estilo anime, etc.).
* Incluye detalles técnicos (como DSLR, alta definición, rico en detalles, etc.).
* Evita contenidos negativos o prohibidos.
* **Evita incluir grandes cantidades de texto en los prompts**, usa solo palabras clave esenciales para obtener resultados más estables.
## Generación de imágenes con Gemini
Gemini también ofrece capacidades de generación de imágenes como alternativa. En comparación con Imagen, la generación de imágenes de Gemini se adapta mejor a escenarios que requieren comprensión y razonamiento contextual, en lugar de buscar la máxima expresión artística y calidad visual.
**Instrucciones:**
* ID de modelo: `gemini-2.5-flash-image-preview`
* Precios de entrada/salida: Texto: \$0.3→\$2.5/M tokens; Imagen: \$0.3→\$30/M tokens
* Se requiere añadir parámetros para experimentar nuevas funciones: `"modalities":["text","image"]`
* Las imágenes se pasan y se devuelven en codificación Base64
* La altura predeterminada de las imágenes de salida es 1024 px
* Las llamadas en Python requieren el SDK más reciente de OpenAI; ejecuta primero `pip install -U openai`
* Para más información, visita la [documentación oficial de Gemini](https://ai.google.dev/gemini-api/docs/image-generation)
**Estructura de referencia de entrada:**
```json theme={null}
"modalities": ["text","image"]
{
"model": "gemini-2.5-flash-image-preview",
"messages": [
{
"role": "user",
"content": "Generate a landscape painting and provide a poem to describe it"
}
],
"modalities":["text","image"], //need to add image
"temperature": 0.7
}'
```
**Estructura de referencia de salida:**
```json theme={null}
"choices":
[
{
"index": 0,
"message":
{
"role": "assistant",
"content": "Hello! How can I assist you today?",
"refusal": null,
"multi_mod_content": //📍 New addition
[
{
"text": "",
"inlineData":
{
"data":"base64 str",
"mimeType":"png"
}
},
{
"text": "hello",
"inlineData":
{
}
}
],
"annotations":
[]
},
"logprobs": null,
"finish_reason": "stop"
}
],
```
### Generación de texto a imagen
Entrada: texto
Salida: texto + imagen
```shell Curl theme={null}
IMG_PATH="/your_path/image.jpg"
if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
B64FLAGS="--input"
else
B64FLAGS="-w0"
fi
IMG_BASE64=$(base64 "$B64FLAGS" "$IMG_PATH" 2>&1)
curl https://aihubmix.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer sk-***" \
-d '{
"model": "gemini-2.5-flash-image-preview",
"messages": [
{
"role": "user",
"content": [
{
"type":"text",
"text":"describe the image with a concise and engaging paragraph, then fill color as children's crayon style"
},
{
"type": "image_url",
"image_url": {
"url": "data:image/jpeg;base64,'$IMG_BASE64'"
}
}
]
}
],
"modalities": ["text","image"],
"temperature": 0.7
}' \
| grep -o '"data":"[^"]*"' \
| cut -d'"' -f4 \
| base64 --decode > /your_path/imageGen.jpg
```
```py OpenAI Python theme={null}
import os
from openai import OpenAI
from PIL import Image
from io import BytesIO
import base64
client = OpenAI(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
base_url="https://aihubmix.com/v1",
)
# Using text-only input
response = client.chat.completions.create(
model="gemini-2.5-flash-image-preview",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "generate an adorable mermaid in the sea, bold outline, chibi cartoon, in the style of Children coloring book, B&W",
}
],
},
],
modalities=["text", "image"],
temperature=0.7,
)
try:
# Print basic response information
print(f"Creation time: {response.created}")
print(f"Token usage: {response.usage.total_tokens}")
# Check if multi_mod_content field exists
if (
hasattr(response.choices[0].message, "multi_mod_content")
and response.choices[0].message.multi_mod_content is not None
):
print("\nResponse content:")
for part in response.choices[0].message.multi_mod_content:
if "text" in part and part["text"] is not None:
print(part["text"])
# Process image content
elif "inline_data" in part and part["inline_data"] is not None:
print("\n🖼️ [Image content received]")
image_data = base64.b64decode(part["inline_data"]["data"])
mime_type = part["inline_data"].get("mime_type", "image/png")
print(f"Image type: {mime_type}")
image = Image.open(BytesIO(image_data))
image.show()
# Save image
output_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output")
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, "generated_image.png")
image.save(output_path)
print(f"✅ Image saved to: {output_path}")
else:
print("No valid multimodal response received, check response structure")
except Exception as e:
print(f"Error processing response: {str(e)}")
```
```py Gemini Python theme={null}
import mimetypes
from google import genai
from google.genai import types
import os
def save_binary_file(file_name, data):
f = open(file_name, "wb")
f.write(data)
f.close()
print(f"File saved to to: {file_name}")
def generate():
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
model = "gemini-2.5-flash-image-preview"
contents = [
types.Content(
role="user",
parts=[
types.Part.from_text(text="""generate image: an adorable mermaid in the sea, bold outline, chibi cartoon, in the style of Children coloring book, super cute, B&W, HD"""),
],
),
]
generate_content_config = types.GenerateContentConfig(
response_modalities=[
"IMAGE",
"TEXT",
],
)
file_index = 0
for chunk in client.models.generate_content_stream(
model=model,
contents=contents,
config=generate_content_config,
):
if (
chunk.candidates is None
or chunk.candidates[0].content is None
or chunk.candidates[0].content.parts is None
):
continue
if chunk.candidates[0].content.parts[0].inline_data and chunk.candidates[0].content.parts[0].inline_data.data:
file_name = f"ENTER_FILE_NAME_{file_index}"
file_index += 1
inline_data = chunk.candidates[0].content.parts[0].inline_data
data_buffer = inline_data.data
file_extension = mimetypes.guess_extension(inline_data.mime_type)
save_binary_file(f"{file_name}{file_extension}", data_buffer)
else:
print(chunk.text)
if __name__ == "__main__":
generate()
```
**Ejemplo de salida:**
### Editar imagen
Entrada: texto + imagen\
Salida: texto + imagen
```py Python theme={null}
import os
from openai import OpenAI
from PIL import Image
from io import BytesIO
import base64
client = OpenAI(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
base_url="https://aihubmix.com/v1",
)
project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
image_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "resources", "filled.jpg")
if not os.path.exists(image_path):
raise FileNotFoundError(f"image {image_path} not exists")
def encode_image(image_path):
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode("utf-8")
base64_image = encode_image(image_path)
response = client.chat.completions.create(
model="gemini-2.5-flash-image-preview",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "describe the image with a concise and engaging paragraph, then fill color as children's crayon style",
},
{
"type": "image_url",
"image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
},
],
},
],
modalities=["text", "image"],
temperature=0.7,
)
try:
# Print basic response information without base64 data
print(f"Creation time: {response.created}")
print(f"Token usage: {response.usage.total_tokens}")
# Check if multi_mod_content field exists
if (
hasattr(response.choices[0].message, "multi_mod_content")
and response.choices[0].message.multi_mod_content is not None
):
print("\nResponse content:")
for part in response.choices[0].message.multi_mod_content:
if "text" in part and part["text"] is not None:
print(part["text"])
# Process image content
elif "inline_data" in part and part["inline_data"] is not None:
print("\n🖼️ [Image content received]")
image_data = base64.b64decode(part["inline_data"]["data"])
mime_type = part["inline_data"].get("mime_type", "image/png")
print(f"Image type: {mime_type}")
image = Image.open(BytesIO(image_data))
image.show()
# Save image
output_dir = os.path.join(os.path.dirname(image_path), "output")
os.makedirs(output_dir, exist_ok=True)
output_path = os.path.join(output_dir, "edited_image.jpg")
image.save(output_path)
print(f"✅ Image saved to: {output_path}")
else:
print("No valid multimodal response received, check response structure")
except Exception as e:
print(f"Error processing response: {str(e)}")
```
**Ejemplo de salida:**
## Elegir el modelo adecuado
### Cuándo elegir Gemini:
* Cuando necesites aprovechar el conocimiento del mundo y las habilidades de razonamiento para generar imágenes contextualmente relevantes.
* Cuando necesites una integración fluida entre texto e imágenes.
* Cuando quieras incrustar contenido visual preciso en secuencias largas de texto.
* Cuando quieras editar imágenes de forma conversacional manteniendo el contexto.
### Cuándo elegir Imagen:
* Cuando la calidad de imagen, el fotorrealismo, el detalle artístico o los estilos específicos (como impresionismo, anime) sean las consideraciones principales.
* Cuando realices tareas de edición profesional, como actualizaciones de fondos de productos o ampliación de imágenes.
* Cuando incorpores marca, estilo o generes logotipos y diseños de producto.
### Buenas prácticas
1. **Optimizar los prompts**: Elaborar cuidadosamente los prompts es clave para obtener resultados de alta calidad.
2. **Experimentar con los parámetros**: Prueba diferentes relaciones de aspecto y ajustes para encontrar la configuración que mejor se adapte a tus necesidades.
3. **Generación por lotes**: Genera varias imágenes para aumentar las probabilidades de obtener resultados ideales.
4. **Guardar los metadatos**: Guarda los prompts y las marcas temporales junto con las imágenes para rastrear y replicar los resultados exitosos.
5. **Cumplir con las políticas de uso**: Asegúrate de que tu uso cumpla con las políticas de contenido y los términos de servicio de Google.
## Generación de vídeo con Veo 3.0
VEO 3.0 es el último modelo avanzado de generación de vídeo desarrollado por Google DeepMind. Con [VEO 3.0](https://aihubmix.com/models?model=veo-3.0-generate-preview), puedes generar vídeos con las siguientes funciones:
* Calidad mejorada a partir de prompts de texto e imagen
* Habla, como diálogos y locuciones
* Audio, como música y efectos de sonido
1. Actualmente, VEO 3.0 solo admite prompts en inglés; se recomienda la traducción automática al integrarlo
2. Los vídeos suelen generarse en unos minutos, pero pueden tardar más en horas pico
3. Actualmente no admite la generación de vídeo a partir de conversaciones basadas en imágenes
### Limitaciones conocidas
Actualmente, los parámetros de VEO 3.0 son fijos y no se pueden cambiar:
* **Resolución**: 720p (horizontal)
* **Velocidad de fotogramas**: 24fps
* **Duración del vídeo**: 8 segundos
### Precios
El coste de la API de VEO 3.0 es de **\$0.675/segundo** (Aihubmix ofrece un descuento del 10 % por tiempo limitado)
### Ejemplo de uso
VEO 3.0 actualmente solo admite llamadas mediante comandos curl, usando un proceso de dos pasos:
Nota: `sk-***` es tu clave generada en AiHubMix.
```shell Step 1: Initiate Generation Request theme={null}
curl "https://aihubmix.com/gemini/v1beta/models/veo-3.0-generate-preview:predictLongRunning?key=sk-***" \
-H "Content-Type: application/json" \
-X "POST" \
-d '{
"instances":
[
{
"prompt": "A cat playing with a ball"
}
],
"parameters":
{
"numberOfVideos": 1,
"durationSeconds": 8,
"aspectRatio": "16:9",
"personGeneration": "dont_allow"
}
}'
```
```shell Step 2: Get Generation Result theme={null}
# Use the operation ID from the name field returned in Step 1
curl "https://aihubmix.com/gemini/v1beta/models/veo-3.0-generate-preview/operations/ff5***?key=sk-***"
```
```py Video Extraction Script theme={null}
import json
import base64
# 1. Read the response JSON file
with open('yourpath/response.json', 'r') as f:
data = json.load(f)
# 2. Get the base64 encoded video string
b64_str = data['response']['videos'][0]['bytesBase64Encoded']
# 3. Decode and write to mp4 file
with open('output.mp4', 'wb') as f:
f.write(base64.b64decode(b64_str))
print("Video saved as output.mp4")
```
### Ejemplos de respuesta
**Respuesta del paso 1:**
```json theme={null}
{
"name": "models/veo-3.0-generate-preview/operations/ff5***"
}
```
**Respuesta del paso 2 (generación completa):**
```json theme={null}
{
"name": "projects/ahm-gemini-03/locations/us-central1/publishers/google/models/veo-3.0-generate-preview/operations/ff5***",
"done": true,
"response": {
"@type": "type.googleapis.com/cloud.ai.large_models.vision.GenerateVideoResponse",
"raiMediaFilteredCount": 0,
"videos": [
{
"bytesBase64Encoded": "AAA...2xl",
"mimeType": "video/mp4"
}
]
}
}
```
**Respuesta del paso 2 (aún en proceso):**
```json theme={null}
{
"name": "projects/ahm-gemini-03/locations/us-central1/publishers/google/models/veo-3.0-generate-preview/operations/777***"
}
```
Si recibes una respuesta de procesamiento, espera unos minutos y reenvía la solicitud del paso 2.
**Efecto del vídeo:**
### Buenas prácticas
1. **Sé paciente**: La generación de vídeo suele tardar unos minutos, más durante las horas pico
2. **Comprueba el estado**: Si la respuesta no contiene `done: true`, sigue procesándose
3. **Guarda el ID de operación**: Asegúrate de guardar el ID de operación devuelto en el paso 1 para consultas posteriores
4. **Cumple con las políticas de uso**: Asegúrate de que tu uso cumple con las políticas de contenido y los términos de uso de Google
Para más información, consulta la [documentación oficial de Vertex AI](https://cloud.google.com/vertex-ai/generative-ai/docs/video/generate-videos)
## Generación de vídeo con Veo 2.0
VEO 2.0 es un modelo avanzado de IA para generación de vídeo lanzado por Google, capaz de crear vídeos cortos realistas y de alta calidad a partir de prompts de texto. Esta sección te ayudará a entender cómo usar la API de VEO 2.0 para generar vídeos, incluida la configuración de parámetros, la selección de modelo y ejemplos de código.
1. Actualmente, VEO 2.0 solo admite prompts en inglés
2. La generación de vídeo tarda aproximadamente 2-3 minutos; sé paciente
### Parámetros del modelo
VEO 2.0 ofrece los siguientes parámetros:
* **numberOfVideos**: El número de vídeos a generar; las opciones son 1 o 2. Por defecto 2.
* **aspectRatio**: La relación de aspecto de los vídeos generados. Los valores admitidos son "16:9" y "9:16".
* **durationSeconds**: Duración del vídeo; las opciones son 5 segundos u 8 segundos. Por defecto 8 segundos.
* **personGeneration**: Controla si se permiten vídeos que contengan personas. Admite los siguientes valores:
* "dont\_allow": Evita la generación de vídeos que contengan personas.
* "allow\_adult": Permite la generación de vídeos que contengan adultos, pero no niños.
### Precios
El coste de la API de VEO 2.0 es de \$0.35/s
### Ejemplo de uso
A continuación, un ejemplo en Python para usar VEO 2.0 para generar vídeos:
```py Generate from text theme={null}
import os
import time
from google import genai
from google.genai import types
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
operation = client.models.generate_videos(
model="veo-2.0-generate-001",
prompt="Panning wide shot of a calico kitten sleeping in the sunshine",
config=types.GenerateVideosConfig(
person_generation="dont_allow", # "dont_allow" or "allow_adult"
aspect_ratio="16:9", # "16:9" or "9:16"
number_of_videos=1, # Integer, options are 1 or 2, default is 2
durationSeconds=5, # Integer, options are 5 or 8, default is 8
),
)
# Takes 2-3 minutes, video duration is 5-8s
while not operation.done:
time.sleep(20)
operation = client.operations.get(operation)
for n, generated_video in enumerate(operation.response.generated_videos):
client.files.download(file=generated_video.video)
generated_video.video.save(f"video{n}.mp4") # Save the video
```
```py Generate from images theme={null}
import os
import time
from google import genai
from google.genai import types
def load_image(path):
with open(path, "rb") as image_file:
return image_file.read()
client = genai.Client(
api_key="sk-***", # 🔑 Replace with your key generated on AiHubMix
http_options={"base_url": "https://aihubmix.com/gemini"},
)
operation = client.models.generate_videos(
model="veo-2.0-generate-001",
prompt="The waves in the background keep flowing",
image=types.Image(
mime_type="image/png",
image_bytes=load_image("img/inferbanner.png") # your image path
),
config=types.GenerateVideosConfig(
person_generation="dont_allow",
aspect_ratio="16:9",
numberOfVideos=1,
durationSeconds=5,
),
)
while not operation.done:
time.sleep(20)
operation = client.operations.get(operation)
for n, generated_video in enumerate(operation.response.generated_videos):
client.files.download(file=generated_video.video)
generated_video.video.save(f"video{n}.mp4")
```
### Consejos para prompts
Crear prompts eficaces es fundamental para obtener los vídeos deseados:
* Describe escenas, acciones y ambiente claros
* Especifica estilos de filmación (como panorámico, primer plano, planos de seguimiento, etc.)
* Describe las condiciones de iluminación (como soleado, atardecer, iluminación interior, etc.)
* Especifica el sujeto principal y sus acciones (p. ej., "un gatito durmiendo bajo el sol")
* Evita narrativas demasiado complejas o escenas que cambien rápidamente
* Evita contenidos negativos o prohibidos
### Buenas prácticas
1. **Prompts claros y concisos**: Usa descripciones claras y específicas para guiar la generación del vídeo.
2. **La paciencia es clave**: La generación de vídeo tarda 2-3 minutos; espera a que se complete.
3. **Prueba diferentes parámetros**: Experimenta con diferentes relaciones de aspecto y duraciones para encontrar los ajustes que mejor se adapten a tus necesidades.
4. **Guarda los registros de generación**: Registra los prompts junto con los vídeos generados para hacer seguimiento de los resultados exitosos.
5. **Cumple con las políticas de uso**: Asegúrate de que tu uso cumple con las políticas de contenido y los términos de uso de Google.
***
Última actualización: 2026-06-01