Inicio rapido

Otorgar acceso en el nivel de arrendamiento

Para permitir que un grupo de usuarios gestione todos los recursos de IA generativa en todo el arrendamiento:

allow group <your-group-name> to manage generative-ai-family 
in tenancy

Otorgar acceso en el nivel de compartimento

Para restringir el acceso a un compartimento específico:

allow group <your-group-name> to manage generative-ai-family 
in compartment <your-compartment-name>

Una vez que estos permisos estén en su lugar, estará listo para crear el primer proyecto.

Buscar el OCID de clave de API

Para restringir los permisos a una clave de API específica, necesita su OCID.

En la consola:

1. Vaya a la página de lista de claves de API.
2. Seleccione la clave de API que ha creado.
3. Copie el OCID (normalmente comienza con ocid1.generativeaiapikey...).

Otorgar permiso a la clave de API

Cree una política de IAM para permitir que la clave de API llame a la API de respuestas:

allow group <your-group-name> 
to manage generative-ai-response in tenancy where ALL 
{request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Esta política permite que las solicitudes autenticadas con la clave de API especificada accedan a la API de respuestas y, al mismo tiempo, mantengan el ámbito y el control del acceso.

URL de base 🔗

Utilice la siguiente URL base para acceder a la API de respuestas de OCI:

https://inference.generativeai.<region>.oci.oraclecloud.com/openai/v1

Sustituya <region> por el identificador de región adecuado (por ejemplo, us-chicago-1).

Soporte de SDK 🔗

La API de respuestas de OCI es compatible con el SDK de OpenAI, que se recomienda para interactuar con el servicio. Es compatible en muchos lenguajes, incluidos Python, Java, TypeScript, Go y .NET.

También puede utilizarlo con marcos de agentes populares como LangChain, LlamaIndex y OpenAI Agents SDK.

Cuándo utilizar la autenticación de IAM

Considere el uso de la autenticación de IAM cuando:

• Ejecución de aplicaciones en servicios de OCI (por ejemplo, Functions u OKE)
• Evitar credenciales de larga duración como claves de API
• Aplicación de control de acceso detallado mediante políticas de IAM

Instalación de la biblioteca de autenticación de IAM de OCI

Instale la biblioteca oci-genai-auth, que proporciona utilidades auxiliares para integrar la autenticación de OCI IAM con el SDK de OpenAI:

pip install oci-genai-auth

Esta biblioteca incluye los siguientes ayudantes de autenticación:

• OciSessionAuth (para el desarrollo local)
• OciUserPrincipalAuth
• OciInstancePrincipalAuth
• OciResourcePrincipalAuth (para entornos gestionados por OCI)

Configurar el cliente OpenAI

Al utilizar la autenticación de IAM, inicialice el cliente de OpenAI con un cliente HTTP personalizado y un manejador de autenticación. El valor api_key es "not used" en este caso.

Ejemplo: desarrollo local (OciSessionAuth)

Utilice este enfoque al ejecutar código localmente (por ejemplo, en un portátil que utiliza un perfil de la CLI de OCI):

from openai import OpenAI
from oci_openai import OciSessionAuth
import httpx

client = OpenAI(
    base_url="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com/openai/v1",  # update region if needed
    api_key="not-used",
    project="ocid1.generativeaiproject.oc1.us-chicago-1.xxxxxxxx",  # project OCID created earlier
    http_client=httpx.Client(auth=OciSessionAuth(profile_name="DEFAULT"))  # update profile if needed
)

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    input="Write a one-sentence explanation of what a database is."
)

print(response.output_text)

Ejemplo: entornos gestionados de OCI (OciResourcePrincipalAuth)

Utilice este enfoque cuando se ejecute en servicios de OCI como OCI Functions u OCI Container Engine for Kubernetes (OKE):

Si se utiliza la autenticación de OCI IAM

Si ha agregado las políticas en Requisito: Configurar permisos de IAM, omita este paso.

Para permitir que un grupo de usuarios llame a la API de respuestas, agregue la siguiente política:

allow group <your-group-name> 
to manage generative-ai-response in tenancy

Si se utiliza la autenticación de clave de API de IA generativa

Al utilizar la autenticación de clave de API, se necesita otra política para autorizar las solicitudes realizadas con la clave de API. Si ha agregado las políticas en 3. Agregue el permiso a la clave de API; omita este paso.

Para otorgar acceso a una clave de API específica:

allow group <your-group-name> 
to manage generative-ai-response in tenancy 
where ALL {request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Para un acceso más amplio (por ejemplo, durante las pruebas), puede utilizar una política más general:

allow any-user 
to manage generative-ai-family in tenancy 
where ALL {request.principal.type='generativeaiapikey', 
request.principal.id='<your-api-key-OCID>'}

Estas políticas garantizan que las solicitudes, ya sean autenticadas mediante IAM o claves de API, estén autorizadas para acceder a los recursos de OCI Generative AI.

Modelos alojados de terceros

OCI Generative AI proporciona acceso a modelos de proveedores de terceros. Especifique el modelo con su nombre completo:

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    input="Write a one-sentence explanation of what a database is."
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input="Write a one-sentence explanation of what a database is."
)

Modelos bajo demanda

Los modelos a demanda los aloja y gestiona OCI, y están disponibles sin necesidad de infraestructura dedicada:

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Write a one-sentence explanation of what a database is."
)

Clusters de IA dedicados (modo dedicado)

Para cargas de trabajo de producción que requieren aislamiento o rendimiento predecible, puede desplegar modelos en un cluster de IA dedicado. En este caso, utilice el OCID de punto final de cluster como identificador de modelo:

response = client.responses.create(
    model="<dedicated-ai-cluster-endpoint-ocid>",
    input="Write a one-sentence explanation of what a database is."
)

Transmitir todos los eventos

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    print(event)

Salida de texto de solo flujo (tokens Delta)

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Explain the difference between structured and unstructured data.",
    stream=True
)

for event in response_stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Streaming es especialmente útil para aplicaciones interactivas en las que desea mostrar respuestas a los usuarios a medida que se generan.

Integración con herramientas de observación 🔗

Para obtener información más detallada, como rastreos de latencia, costos y ejecución, puedes integrar la API de respuestas de OCI con plataformas de observación.

Muchos proveedores admiten API compatibles con OpenAI. Una de estas opciones es Langfuse, una plataforma de ingeniería de LLM de código abierto que ayuda a los desarrolladores a depurar, supervisar y mejorar las aplicaciones de LLM. Proporciona una capacidad de observación integral para rastrear acciones del agente, soporta el control de versiones de petición de datos y ayuda con la evaluación de las salidas del modelo. Langfuse se integra con marcos populares como OpenAI, LangChain y LlamaIndex.

En el siguiente ejemplo se muestra cómo utilizar Langfuse para rastrear y supervisar las llamadas de API de respuestas.

Paso 1: Instalar el SDK de Langfuse

pip install langfuse

Paso 2: Configurar variables de entorno

Defina las variables de entorno de Langfuse y OCI necesarias:

LANGFUSE_SECRET_KEY="sk-lf-xxxxxxxxx"
LANGFUSE_PUBLIC_KEY="pk-lf-xxxxxxxxx"
LANGFUSE_BASE_URL="https://us.cloud.langfuse.com"

# OCI Generative AI credentials
OCI_GENAI_API_KEY="sk-xxxxxxxxx"
OCI_GENAI_PROJECT_ID="ocid1.generativeaiproject.oc1.xxx"

Paso 3: Instrumentalizar el cliente OpenAI

Importe el cliente OpenAI desde el SDK de Langfuse. El código existente permanece sin cambios, pero las solicitudes se rastrean automáticamente.

import os
from langfuse.openai import OpenAI  # Import from Langfuse

client = OpenAI(
    base_url="https://inference.generativeai.us-ashburn-1.oci.oraclecloud.com/openai/v1",
    api_key=os.getenv("OCI_GENAI_API_KEY"),
    project=os.getenv("OCI_GENAI_PROJECT_ID"),
)

# Requests are automatically instrumented by Langfuse
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "dmcp",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": "never",
        },
    ],
    input="Explain why tracing and observability are important in distributed systems."
)

print(response.output_text)

Esta integración proporciona una visibilidad integral de las llamadas de API sin necesidad de realizar cambios significativos en el código de la aplicación.

Entrada de imagen como URL de datos codificados en Base64

import base64

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("/path/to/image.png")

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the main objects in this image."},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{base64_image}",
                    "detail": "high",
                },
            ],
        }
    ],
)

print(response.output_text)

Entrada de imagen como URL accesible a Internet

response = client.responses.create(
    model="openai.gpt-oss-120b",
    store=False,
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the scene shown in this image."},
                {
                    "type": "input_image",
                    "image_url": "https://example.photos/id/123",
                },
            ],
        }
    ],
)

print(response.output_text)

Sustituya "image_url" por una URL de imagen válida.

Entrada de archivo como ID de archivo

file = client.files.create(
    file=open("<path-to-file>", "rb"),
    purpose="user_data"
)

response = client.responses.create(
    model="google.gemini-2.5-pro",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_file",
                    "file_id": file.id,
                },
                {
                    "type": "input_text",
                    "text": "Summarize this document.",
                },
            ]
        }
    ]
)

print(response.output_text)

Entrada de archivo como URL accesible a Internet

response = client.responses.create(
    model="google.gemini-2.5-flash",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Summarize this file."},
                {
                    "type": "input_file",
                    "file_url": "https://www.example.com/letters/example-letter.pdf",
                },
            ],
        }
    ],
)

print(response.output_text)

Esfuerzo de razonamiento

import json

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"effort": "medium"},
    store=False,
)

print(response.output_text)

Salida de resumen de razonamiento

Si está creando un chatbot, la activación de resúmenes de razonamiento puede ayudar a los usuarios a comprender mejor cómo llegó el modelo a un resultado. Durante la transmisión, los usuarios también pueden ver tokens de razonamiento mientras el modelo está pensando.

import json

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Solve 18 * (4 + 2).",
    reasoning={"summary": "auto"},
    store=False,
)

print(response.output_text)

Lo que esto permite

Las herramientas de función son útiles cuando la aplicación necesita mantener el control de la ejecución mientras permite que el modelo decida cuándo se necesita información externa.

Los casos de utilización habituales incluyen:

• Consulta de eventos de calendario
• Recuperando datos de aplicación
• Llamada a API internas o externas
• Ejecución de cálculos o lógica de negocio

Este enfoque proporciona flexibilidad a la vez que mantiene la ruta de ejecución dentro de la aplicación.

Flujo de ejecución 🔗

Una interacción típica de la herramienta de función funciona así:

1. El cliente envía una solicitud que incluye una o más definiciones de herramienta.
2. El modelo decide si una de esas herramientas es necesaria.
3. Si se necesita una herramienta, el modelo devuelve el nombre y los argumentos de la herramienta.
4. La aplicación ejecuta la herramienta y prepara el resultado.
5. La aplicación envía ese resultado de nuevo en una solicitud de seguimiento.
6. El modelo utiliza ese resultado para completar la respuesta.

Opciones de manejo de estado 🔗

Existen dos formas comunes de gestionar el estado en estas solicitudes:

• Estado gestionado por servicio: se recomienda para la mayoría de los casos de uso. La solicitud de seguimiento incluye previous_response_id y el servicio realiza un seguimiento del intercambio anterior.
• Estado gestionado por el cliente: la aplicación mantiene todo el historial de interacciones y envía el contexto acumulado con cada solicitud.

Definición de una herramienta de función

El siguiente ejemplo define una herramienta que recupera eventos de calendario para una fecha especificada.

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

Incluya esta matriz tools en la solicitud client.responses.create().

Ejemplo: Estado Gestionado por Servicio

En este patrón, la primera solicitud permite al modelo decidir si la herramienta es necesaria. La segunda solicitud devuelve el resultado de la herramienta y hace referencia a la respuesta anterior.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

# Initial request
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input="Show the calendar events for 2026-04-02.",
)

# Execute the requested function
tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        tool_outputs.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

# Follow-up request
final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=tool_outputs,
    previous_response_id=response.id,
)

print(final.output_text)

Ejemplo: Estado Gestionado por Servicio

En este patrón, la aplicación mantiene el intercambio completo y lo vuelve a enviar con la solicitud de seguimiento.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

conversation = [
    {"role": "user", "content": "Show the calendar events for 2026-04-02."}
]

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input=conversation,
)

conversation += response.output

for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        conversation.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=conversation,
)

print(final.output_text)

Las herramientas funcionales son una opción sólida cuando la aplicación debe seguir siendo responsable de la ejecución, el control de acceso y la lógica de integración, al tiempo que permite al modelo solicitar la información que necesita.

Cuándo se debe utilizar la herramienta MCP

Utilice la herramienta MCP cuando el modelo necesite acceso a capacidades externas alojadas en un servidor MCP.

Este enfoque es útil cuando se desea:

• El servicio para comunicarse directamente con el servidor MCP
• Menos pasos de orquestación del cliente
• Menor latencia que un patrón de herramienta ejecutado por el cliente
• Acceso a las capacidades expuestas a través de un servidor MCP remoto

La herramienta MCP forma parte del conjunto de herramientas de OCI Generative AI y se puede utilizar junto con otras herramientas compatibles.

Soporte de transporte

Las llamadas MCP remotas utilizan Streamable HTTP.

Definición de una herramienta MCP

Agregue la definición del servidor MCP en el campo tools de la solicitud.

response_stream = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_description": "An MCP server that retrieves calendar events for a specified date.",
            "server_url": "https://example.com/mcp",
            "require_approval": "never",
        },
    ],
    input="What events are scheduled for 2026-04-02?",
    stream=True,
)

for event in response_stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

En este ejemplo, se transmite la respuesta y se imprime el texto a medida que se genera.

Restricción de las herramientas expuestas por el servidor MCP

Si el servidor MCP remoto expone más herramientas de las que necesita la aplicación, puede limitar el juego disponible mediante allowed_tools.

response_stream = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_description": "An MCP server that retrieves calendar events for a specified date.",
            "server_url": "https://example.com/mcp",
            "require_approval": "never",
            "allowed_tools": ["get_events"],
        },
    ],
    input="Show the calendar events for 2026-02-02.",
    stream=True,
    store=False,
)

Proporcionar autenticación al servidor MCP

response_stream = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    tools=[
        {
            "type": "mcp",
            "server_label": "calendar",
            "server_url": "https://calendar.example.com/mcp",
            "authorization": "$CALENDAR_OAUTH_ACCESS_TOKEN"
        },
    ],
    input="List my meetings for 2026-02-02.",
    stream=True,
    store=False,
)

Transfiera solo el valor de token. No incluya el prefijo Bearer. OCI envía el token a través de TLS como parte de la solicitud y no lo descodifica, inspecciona, almacena ni registra.

Alojamiento de servidores MCP

OCI Generative AI también proporciona alojamiento de servidores MCP para ayudar a desplegar y escalar servidores MCP.

La herramienta MCP es una buena opción cuando desea que OCI Generative AI funcione directamente con un servidor MCP remoto durante la ejecución de la solicitud, sin necesidad de que la aplicación cliente maneje cada paso de la herramienta en sí.

Preparar una tienda de vectores

Antes de utilizar la búsqueda de archivos, cree un almacén de vectores y agregue los archivos a los que desea que haga referencia el modelo. OCI Generative AI soporta varios patrones de manejo de archivos a través de API que siguen el estilo de API de archivos de OpenAI.

Ejemplo

Para que la búsqueda de archivos esté disponible en una solicitud, agregue una entrada de herramienta con type: "file_search" y proporcione el ID de almacén de vectores.

response = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Summarize the main ideas covered in the documents in this vector store.",
    tools=[
        {
            "type": "file_search",
            "vector_store_ids": ["<vector_store_id>"]
        }
    ]
)

print(response)

Para qué se puede utilizar

Si lo está utilizando por primera vez, ayuda pensar en Code Interpreter como un espacio de trabajo temporal de Python para el modelo.

Puede utilizarlo para tareas como:

• resolver problemas matemáticos
• análisis de archivos cargados
• limpieza o transformación de datos
• creación de gráficos o tablas
• generación de archivos de salida como logs o juegos de datos procesados

Entorno de Ejecución

El entorno de Python incluye más de 420 bibliotecas preinstaladas, por lo que muchas tareas comunes funcionan sin configuración adicional.

El código se ejecuta dentro de un contenedor. Este contenedor es el entorno de trabajo donde se ejecuta Python y donde se almacenan los archivos durante la sesión.

Límites de memoria de contenedor

Los contenedores de Code Interpreter utilizan un pool de memoria compartida de 64 GB por arrendamiento.

Los tamaños de contenedor soportados son:

• 1 GB
• 4 GB
• 16 GB
• 64 GB

Este límite compartido se puede dividir en varios contenedores. Por ejemplo, podría soportar:

• sesenta y cuatro contenedores de 1 GB
• dieciséis contenedores de 4 GB
• cuatro contenedores de 16 GB
• un contenedor de 64 GB

Si necesita más capacidad, puede enviar una solicitud de servicio.

Caducidad de contenedor

Un contenedor caduca después de 20 minutos de inactividad.

Esto es importante saber al crear flujos de varios pasos:

• no se puede reutilizar un contenedor caducado
• debe crear un nuevo contenedor
• los archivos se deben volver a cargar si es necesario
• el estado en memoria, como las variables de Python, se pierde

Debido a esto, es mejor tratar los contenedores como entornos de trabajo temporales.

Ejemplo

response = client.responses.create(
    model="xai.grok-4-1-fast-reasoning",
    tools=[
        {
            "type": "code_interpreter",
            "container": {"type": "auto"}
        }
    ],
    instructions="Use the python tool to solve the problem and explain the result.",
    input="Find the value of (18 / 3) + 7 * 2."
)

print(response.output_text)

Contenedores para intérprete de código

El intérprete de código necesita un contenedor. El contenedor es el entorno aislado en el que el modelo ejecuta código Python.

Un contenedor puede contener:

• archivos cargados
• archivos creados por el modelo
• datos de trabajo temporales durante la ejecución

Al utilizar Code Interpreter, puede asignar uno de los dos modos de contenedor:

• auto: OCI Generative AI crea el contenedor para usted y le asigna automáticamente un tamaño de contenedor.
• OCID de contenedor: cree el contenedor usted mismo, defina el tamaño del contenedor y proporcione el OCID.

Para ambas opciones, los contenedores se crean y gestionan en OCI Generative AI. El código que se ejecuta en esos contenedores también se ejecuta en el arrendamiento de OCI Generative AI.

Modo automático

En el modo automático, el servicio crea el contenedor. Esta es la opción más fácil y un buen punto de partida para la mayoría de los usuarios.

Utilice el modo automático cuando:

• desea que OCI Generative AI gestione el contenedor
• No necesita control directo sobre el medio ambiente
• desea una configuración más sencilla

response = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[{
        "type": "code_interpreter",
        "container": {
            "type": "auto"
        }
    }],
    input="Use the python tool to calculate the average of 12, 18, 24, and 30."
)

Modo explícito

En el modo explícito, primero debe crear el contenedor y definir el tamaño. A continuación, transfiera el ID de contenedor en la solicitud.

Utilice el modo explícito cuando desee tener más control sobre los detalles del contenedor, como el tamaño de la memoria.

container = client.containers.create(name="test-container", memory_limit="4g")

response = client.responses.create(
    model="xai.grok-code-fast-1",
    tools=[{
        "type": "code_interpreter",
        "container": container.id
    }],
    tool_choice="required",
    input="Use the python tool to calculate the average of 12, 18, 24, and 30."
)

print(response.output_text)

Archivos en Code Interpreter

El intérprete de código puede trabajar con archivos durante la vida útil del contenedor. El modelo puede leer los archivos que proporcione y también puede crear nuevos archivos.

Esto resulta útil para flujos de trabajo como:

• lectura de un CSV o PDF
• generación de un gráfico
• guardado de salida procesada
• creación de logs o informes

Persistencia de archivos 🔗

Los archivos creados o modificados por la herramienta python permanecen disponibles en el mismo contenedor siempre que el contenedor no haya caducado.

Esto significa que el modelo puede basarse en trabajos anteriores en la misma sesión. Por ejemplo, puede:

1. leer un archivo
2. analizarlo
3. guardar un gráfico
4. utilizar ese gráfico más adelante en el mismo contenedor

Cuando el contenedor caduca, ese estado ya no está disponible.

Carga y gestión de archivos 🔗

Puede gestionar archivos de contenedor mediante las API de archivo de contenedor.

Las operaciones comunes incluyen:

• Crear archivo de contenedor: agregue un archivo al contenedor
• Mostrar Archivos de Contenedor: Ver Archivos en el Contenedor
• Suprimir archivo de contenedor: eliminación de un archivo
• Recuperar Contenido de Archivo de Contenedor: Descargue un archivo del contenedor

Esto le permite utilizar el contenedor como espacio de trabajo temporal para la ejecución de código controlado por modelo.

Archivos de salida y citas 🔗

Cuando el modelo crea archivos, estos archivos se almacenan en el contenedor y se puede hacer referencia a ellos en la respuesta.

Estas referencias incluyen:

• container_id
• file_id
• filename

Estos valores se pueden utilizar para recuperar el contenido del archivo generado.

La API de respuestas de OCI soporta puntos finales compatibles con OpenAI para funciones como respuestas, archivos, contenedores y archivos de contenedor. Por este motivo, la documentación de OpenAI relacionada se puede utilizar como referencia para la estructura de solicitudes, los formatos de respuesta y los flujos de trabajo generales. Sin embargo, al utilizar estas API con OCI, envíe solicitudes a los puntos finales de inferencia de OCI Generative AI, utilice la autenticación de OCI y tenga en cuenta que los recursos y la ejecución permanecen en OCI Generative AI, no en un arrendamiento de OpenAI.

Requisitos

Antes de utilizar la herramienta NL2SQL, cree una base de datos y configure las conexiones de base de datos necesarias.

Para obtener más información, consulte:

• Clonar una instancia de base de datos de IA autónoma
• Uso de la consola de Oracle Cloud Infrastructure

Permisos para almacenes semánticos

Acceso a secretos

Otorgue acceso al grupo para leer los secretos utilizados por Database Tools:

allow group <your-group-name> 
to read secret-family in compartment <your-compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

Acceso a conexiones de Database Tools

Otorgue al grupo acceso a los recursos necesarios de Database Tools:

allow group <your-group-name> 
to use database-tools-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

allow group <your-group-name> 
to read database-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

allow group <your-group-name> 
to read autonomous-database-family in compartment <compartment-name> 
where all {request.principal.type='generativeaisemanticstore'}

Acceso a recursos de IA generativa

Si la política más amplia a continuación ya está en vigor, incluye el acceso a los recursos del almacén semántico:

allow group <your-group-name> 
to manage generative-ai-family in tenancy

Si desea un acceso más restringido, utilice la siguiente política en su lugar para permitir que el grupo cree y gestione almacenes semánticos:

allow group <your-group-name> 
to manage generative-ai-semantic-store 
in compartment <your-compartment-name>

Si el grupo solo necesita utilizar un almacén semántico existente y llamar a NL2SQL, utilice estas políticas más específicas:

allow group <your-group-name> 
to use generative-ai-semantic-store 
in compartment <your-compartment-name>

allow group <your-group-name> 
to manage generative-ai-nl2sql 
in compartment <your-compartment-name>

Encadenamiento de respuestas

Con el encadenamiento de respuestas, cada nueva respuesta apunta a la anterior. Esta es una opción sencilla cuando se desea trasladar el contexto sin crear explícitamente un recurso de conversación.

# first turn
response1 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Give me three ideas for a team offsite.",
)
print("Response 1:", response1.output_text)

# second turn
response2 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Make the second idea more budget friendly.",
    previous_response_id=response1.id,
)
print("Response 2:", response2.output_text)

API de Conversaciones

# create a conversation
conversation = client.conversations.create(
    metadata={"topic": "demo"}
)
print("Conversation ID:", conversation.id)

# first turn
response1 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Give me three ideas for a team offsite.",
    conversation=conversation.id,
)
print("Response 1:", response1.output_text)

# second turn
response2 = client.responses.create(
    model="openai.gpt-oss-120b",
    input="Make the second idea more budget friendly.",
    conversation=conversation.id,
)
print("Response 2:", response2.output_text)