Tutorial de Compactação de API do OCI Responses

Use o SDK Python do OpenAI com a API de Respostas do OCI para compactar o histórico de conversas de forma explícita ou automática e, em seguida, continue a conversa com o contexto retornado.

Visão Geral

À medida que uma conversa cresce, um aplicativo envia mais histórico com cada solicitação. A compactação reduz esse histórico a uma representação menor que o modelo pode usar em revezamentos posteriores. Use-o para gerenciar o contexto em conversas de longa execução e fluxos de trabalho do agente.

Neste tutorial, você descreve uma configuração de implantação fictícia, compacta a conversa e faz uma pergunta de acompanhamento para verificar quais detalhes o modelo retido.

Você usa o SDK Python OpenAI com uma chave de API do OCI Generative AI e um ponto final regional do OCI. O SDK fornece a interface do cliente. As solicitações são autenticadas com a OCI e enviadas para a OCI Generative AI.

Todos os modelos suportados pela API de Respostas do OCI, incluindo modelos importados, suportam compactação explícita e automática. A compactação está disponível em regiões de IA empresarial e segue a região e a disponibilidade de hospedagem de cada modelo. Ambos os modos são suportados para inferência sob demanda e hospedagem dedicada.

Modos de Compactação
ModoOperaçãoO que enviar em seguida
Explícito (autônomo) Chame client.responses.compact(...), que envia POST /responses/compact, quando um aplicativo estiver pronto para compactar o histórico. Informe o array output retornado completo, seguido pela próxima mensagem do usuário.
Automático (gerenciado pelo servidor) Chame client.responses.create(...) com context_management e um limite de token. O OCI compacta o contexto durante o POST /responses quando o limite é atingido. Com store=False, informe o item de compactação mais recente e todos os próximos itens de saída, seguidos pela próxima mensagem do usuário. Se nenhum item de compactação for retornado, mantenha o histórico existente e anexe a nova saída.

Os itens de compactação contêm contexto criptografado e opaco. Preservar os campos serializados e a ordem. Não leia, edite ou substitua seu conteúdo por um resumo de texto.

Observação

A compactação consome tokens de modelo e pode perder detalhes durante a consolidação. Compactar antes de atingir o limite de contexto do modelo e deixar espaço para a resposta e voltas posteriores. A compactação explícita é síncrona e não oferece suporte a armazenamento, execução em segundo plano ou streaming.

Os exemplos gerenciam o histórico no aplicativo e definem store=False em solicitações de criação de resposta. Para o workflow separado que usa o estado de conversa gerenciado pelo OCI, consulte Usar Memória do Agente com API de Respostas.

Antes de Começar

Para concluir este tutorial, você precisa:

Os exemplos usam o Python SDK OpenAI com credenciais do OCI e um URL base do OCI. Eles não exigem uma chave de API OpenAI, o SDK do OCI Python ou a CLI do OCI.

Esses exemplos usam a autenticação de chave da API do OCI Generative AI. A compactação também suporta autenticação do OCI IAM. Para essa configuração, consulte Autenticação Baseada em IAM do Serviço Generative AI. É necessário um OCID de projeto do OCI Generative AI com qualquer um dos métodos de autenticação.

1. Preparar o Ambiente Python e o Acesso ao OCI

  1. Em um diretório de trabalho, crie e ative um ambiente virtual e instale o OpenAI Python SDK:
    python3 -m venv .venv
    source .venv/bin/activate
    python -m pip install --upgrade 'openai>=2.45.0'

    Se o .venv já existir, ative-o e execute o comando de instalação.

  2. Defina um URL base do OCI, um ID de modelo e um OCID de projeto:
    export OCI_BASE_URL='https://inference.generativeai.<REGION>.oci.oraclecloud.com/openai/v1'
    export OCI_MODEL='<MODEL_ID>'
    export OCI_OPENAI_PROJECT='<PROJECT_OCID>'

    Substitua os placeholders pelos valores:

    • <REGION>: Um identificador de região do OCI suportado, como us-chicago-1. O URL base deve terminar em /openai/v1. Não anexe /responses.
    • <MODEL_ID>: O ID de um modelo sob demanda que suporta a API de Respostas do OCI e está disponível para sua tenancy na região selecionada. Use o mesmo modelo em cada exemplo. Para usar um modelo hospedado em um cluster de IA dedicado, consulte Usar um Modelo Hospedado em um Cluster de IA Dedicado.
    • <PROJECT_OCID>: OCID do projeto do OCI Generative AI. Para obter orientação, consulte o Guia de Início Rápido.

    Cada script passa o OCID do projeto por meio de OpenAI(..., project=...). O SDK adiciona o cabeçalho de solicitação OpenAI-Project automaticamente. Esse valor identifica um projeto do OCI.

  3. Prepare sua chave de API do OCI Generative AI.
    Cada script lê OCI_GENAI_API_KEY se for definido pelo seu gerenciador de segredos ou outro mecanismo seguro. Caso contrário, ela solicitará a chave sem exibi-la. Não adicione a chave aos scripts ou confirme-a em um repositório.

2. Compactar uma conversa explicitamente

Este exemplo cria uma resposta, adiciona a saída de resposta completa ao histórico e chama responses.compact. Em seguida, ele substitui o histórico pela saída compactada completa e pergunta sobre a janela de retenção e manutenção de backup da implantação.

A conversa curta torna a sequência fácil de seguir. Em um aplicativo, chame a compactação quando o histórico acumulado precisar ser reduzido e ainda se ajustar ao limite de contexto do modelo.

  1. Salve o seguinte código como standalone_compaction.py:
    """Compact a conversation with the OCI Responses API."""
    
    import os
    from getpass import getpass
    
    from openai import OpenAI
    
    
    def main() -> None:
        model = os.environ["OCI_MODEL"]
        api_key = os.environ.get("OCI_GENAI_API_KEY") or getpass(
            "OCI Generative AI API key: "
        )
        client = OpenAI(
            api_key=api_key,
            base_url=os.environ["OCI_BASE_URL"],
            project=os.environ["OCI_OPENAI_PROJECT"],
        )
        history = [{
            "role": "user",
            "content": (
                "Remember our deployment configuration: Frankfurt region, three "
                "application instances, PostgreSQL, daily backups with 30-day "
                "retention, and maintenance on Sunday at 02:00 UTC. "
                "Summarize the configuration."
            ),
        }]
    
        response = client.responses.create(model=model, input=history, store=False)
        print(response.output_text)
        history.extend(
            item.model_dump(mode="json", exclude_none=True)
            for item in response.output
        )
    
        compacted = client.responses.compact(model=model, input=history)
        print("Compaction observed:", any(
            item.type == "compaction" for item in compacted.output
        ))
    
        # Keep the complete compacted output, including any retained messages.
        history = [
            item.model_dump(mode="json", exclude_none=True)
            for item in compacted.output
        ]
        history.append({
            "role": "user",
            "content": "What are our backup retention and maintenance window?",
        })
        response = client.responses.create(model=model, input=history, store=False)
        print(response.output_text)
        client.close()
    
    
    if __name__ == "__main__":
        main()
  2. Com o ambiente virtual ativado, execute o script:
    python standalone_compaction.py
  3. Revise a saída e a resposta de acompanhamento.

    Compaction observed: True indica que um item de compactação foi retornado. Verifique se a resposta de acompanhamento mantém a retenção de backup de 30 dias e a janela de manutenção de domingo às 02:00 UTC. A redação exata pode variar.

    O script envia todos os itens do compacted.output para a próxima solicitação. Não mantenha apenas o item cujo type seja compaction: o array retornado pode conter outro contexto necessário para continuação.

3. Ativar Compactação Automática

Para compactação automática, inclua context_management em uma solicitação de criação de resposta com type: "compaction" e um compact_threshold explícito de pelo menos 1000 tokens. Selecione um limite menor que o limite de contexto do modelo e deixe espaço para saída e voltas posteriores.

Este exemplo cria 40 trocas de status sintético localmente para construir um histórico mais longo. Ele envia esse histórico em uma solicitação com um limite de 1.000 tokens, verifica a compactação e envia uma solicitação de acompanhamento. As 40 exchanges não fazem chamadas de API separadas.

  1. Salve o seguinte código como server_compaction.py:
    """Use automatic compaction with the OCI Responses API."""
    
    import os
    from getpass import getpass
    
    from openai import OpenAI
    
    
    def main() -> None:
        model = os.environ["OCI_MODEL"]
        api_key = os.environ.get("OCI_GENAI_API_KEY") or getpass(
            "OCI Generative AI API key: "
        )
        client = OpenAI(
            api_key=api_key,
            base_url=os.environ["OCI_BASE_URL"],
            project=os.environ["OCI_OPENAI_PROJECT"],
        )
        context_management = [{"type": "compaction", "compact_threshold": 1000}]
        history = [{
            "role": "user",
            "content": (
                "Remember our deployment configuration: Frankfurt region, three "
                "application instances, PostgreSQL, daily backups with 30-day "
                "retention, and maintenance on Sunday at 02:00 UTC."
            ),
        }]
    
        # Build synthetic history locally. These exchanges don't call the API.
        for day in range(1, 41):
            history.extend([
                {
                    "role": "user",
                    "content": (
                        f"Day {day}: health checks passed, database connections "
                        "are stable, and the daily backup completed. "
                        "Keep the deployment configuration unchanged."
                    ),
                },
                {
                    "role": "assistant",
                    "content": [{
                        "type": "output_text",
                        "text": (
                            f"Day {day} status recorded. "
                            "The deployment configuration remains unchanged."
                        ),
                    }],
                },
            ])
        history.append({
            "role": "user",
            "content": "Summarize our deployment configuration.",
        })
    
        response = client.responses.create(
            model=model,
            input=history,
            store=False,
            extra_body={"context_management": context_management},
        )
        print(response.output_text)
        output = [
            item.model_dump(mode="json", exclude_none=True)
            for item in response.output
        ]
        boundaries = [
            index for index, item in enumerate(output)
            if item["type"] == "compaction"
        ]
        print("Compaction observed:", bool(boundaries))
    
        # Keep the latest compaction item and everything after it.
        # Without a new compaction item, retain history and append all output.
        history = output[boundaries[-1]:] if boundaries else history + output
        history.append({
            "role": "user",
            "content": "What are our backup retention and maintenance window?",
        })
        response = client.responses.create(
            model=model,
            input=history,
            store=False,
            extra_body={"context_management": context_management},
        )
        print(response.output_text)
        client.close()
    
    
    if __name__ == "__main__":
        main()
  2. Execute o script:
    python server_compaction.py
  3. Verifique se a compactação ocorreu e revise a resposta de acompanhamento.

    O script imprime Compaction observed: True quando a primeira resposta inclui um item de compactação. Verifique se o acompanhamento retém a janela de retenção e manutenção de backup.

    O valor False significa que nenhum item de compactação foi retornado. O script preserva o histórico existente e anexa a saída completa para que possa continuar sem eliminar o contexto. Consulte Diagnosticando e Solucionando Problemas se você esperava uma compactação.

    O argumento extra_body adiciona context_management à solicitação JSON. Com store=False, repita a mesma lógica de tratamento de histórico após cada resposta ao estender esse exemplo para mais voltas.

4. Usar um Modelo Hospedado em um Cluster de IA Dedicado (Opcional)

Você pode usar modelos que suportam a API de Respostas da OCI para inferência sob demanda ou hospedá-los em clusters de IA dedicados, de acordo com as opções de hospedagem de cada modelo. Ambos os modos de compactação funcionam com qualquer uma das opções de hospedagem. Os exemplos anteriores usam um ID de modelo sob demanda. Quando hospeda um modelo em um cluster de IA dedicado, você cria um ponto final de modelo nesse cluster para chamar o modelo. Informe o OCID desse ponto final como o valor model da solicitação.

O cluster de hospedagem fornece os recursos de Computação para inferência. Você pode criar vários pontos finais para o mesmo modelo hospedado, por exemplo, para fornecer a diferentes aplicativos, equipes ou centros de custo seus próprios pontos de acesso. Cada ponto final tem seu próprio OCID e os pontos finais compartilham os recursos de Computação do cluster. Para obter mais informações, consulte Gerenciando Pontos Finais de Modelo.

  1. Selecione um modelo que suporte a API de Respostas do OCI e esteja disponível para hospedagem dedicada na região na qual você deseja trabalhar.

    Verifique a compatibilidade da API em Modelos e Regiões Suportados e, em seguida, verifique as opções de hospedagem do modelo:

    • Modelos de base: OpenAI gpt-oss-20b e OpenAI gpt-oss-120b suportam inferência sob demanda e hospedagem dedicada no Centro-Oeste dos EUA (Chicago), Alemanha Central (Frankfurt) e Japão Central (Osaka). Para obter disponibilidade em outras regiões, consulte Modelos por Região.
    • Modelos importados: Os modelos importados suportados incluem Qwen/Qwen3.6-35B-A3B e google/gemma-4-31B-it. Esses modelos exigem Importação de Modelo e um ponto final em um cluster de IA dedicado de hospedagem. Não estão disponíveis sob demanda. Siga os links de modelo para obter as formas de hardware e os requisitos de implantação suportados.

    A compactação explícita e automática é suportada por esses modelos básicos e importados. Use um dos exemplos com o ponto final do modelo que você cria.

  2. Crie ou reutilize um ponto final de modelo em um cluster de IA dedicado de hospedagem compatível.

    Se você precisar de um cluster de hospedagem, siga Criando um Cluster de IA Dedicado para Modelos de Hospedagem. Depois que o cluster se tornar ativo, siga Criando um Ponto Final para selecionar o modelo e o cluster de hospedagem. Aguarde a ativação do ponto final do modelo.

  3. Copie o OCID do ponto final do modelo de sua página de detalhes.
    Se o cluster tiver vários pontos finais, selecione o ponto final que você deseja que este aplicativo use. Consulte Obtendo Detalhes de um Ponto Final.
  4. Defina o URL base do OCI da região do ponto final e atualize o modelo e as variáveis do projeto:
    export OCI_BASE_URL='https://inference.generativeai.<REGION>.oci.oraclecloud.com/openai/v1'
    export OCI_MODEL='<INFERENCE_ENDPOINT_OCID>'
    export OCI_OPENAI_PROJECT='<PROJECT_OCID>'

    Substitua <INFERENCE_ENDPOINT_OCID> pelo OCID do ponto final do modelo que você copiou. O script passa esse valor como model. Defina <REGION> como a região do ponto final e <PROJECT_OCID> como o OCID do projeto do OCI Generative AI. O cliente continua usando o URL base da API de Respostas do OCI regional. Use uma chave de API do OCI Generative AI autorizada a acessar o ponto final e o projeto.

  5. Execute o exemplo de compactação explícita ou automática:

    Para compactação explícita, execute:

    python standalone_compaction.py

    Para compactação automática, execute:

    python server_compaction.py

    Ambos os scripts usam o OCID do ponto final de inferência como modelo para todas as solicitações. Revise o indicador de compactação retornado e a resposta de acompanhamento conforme descrito no exemplo de compação explícita ou compação automática.

Verificar os Resultados

Um item de compactação retornado confirma que ocorreu a compactação. Não se sabe se todos os detalhes foram preservados. Revise a resposta de acompanhamento em relação à configuração original.

Para avaliar a compactação de um aplicativo, use conversas representativas com fatos e instruções importantes para o fluxo de trabalho. Compare a mesma pergunta de acompanhamento com o histórico completo, com compactação explícita e com compactação automática. Verifique fatos retidos, instruções a seguir, formato de saída e quaisquer chamadas de ferramenta que o workflow exigir.

Execute vários exemplos e ajuste o limite de compactação com base no que você observar. A própria compactação usa tokens de modelo, de modo que um contexto menor não garante menos uso total de token ou respostas mais rápidas para cada solicitação.

Diagnóstico e Solução de Problemas

SintomaO que verificar
Um script reporta uma variável de ambiente ausente.Defina OCI_BASE_URL, OCI_MODEL e OCI_OPENAI_PROJECT no shell em que você executa o script.
401 ou 403Confirme se você está usando uma chave de API da OCI Generative AI e o ponto final da OCI regional correto. Verifique a validade da chave, as permissões do projeto e o acesso ao modelo ou ao ponto final de inferência.
404 para /responses/compactConfirme se o URL base termina em /openai/v1. Verifique se o ID do modelo ou o OCID do ponto final de inferência está correto e disponível na região selecionada.
Uma solicitação relata contexto de projeto ausente.Defina OCI_OPENAI_PROJECT como o OCID do projeto do OCI Generative AI e passe-o por project= ao criar o cliente SDK. O contexto do projeto é necessário para cada modelo.
A compactação automática não retorna um item de compactação.Confirme se a solicitação inclui context_management com type: "compaction" e um limite de pelo menos 1000 tokens. Use um histórico mais longo ou reduza um limite maior, mantendo-o em ou mais de 1.000.
O SDK não tem método responses.compact.Ative o ambiente virtual e instale o openai>=2.45.0. Verifique a versão instalada com python -m pip show openai.
Uma resposta de acompanhamento perde os detalhes esperados.Para compactação explícita, informe o array output retornado completo. Para compactação automática, mantenha o item de compactação mais recente e todos os itens de saída posteriores. Se nenhum item de compactação for retornado, mantenha o histórico existente e a nova saída. A compactação pode perder detalhes, portanto, também avalie o modelo e o limite com conversas representativas.