Um Novo SO? Apps no ChatGPT e Apps SDK (Baseado em MCP): Desbloqueando uma Nova Plataforma

Introdução:

Apps no ChatGPT agora permitem que desenvolvedores de terceiros criem miniaplicativos interativos que vivem dentro da interface de chat. Em vez de enviar os usuários para sites ou aplicativos móveis, esses aplicativos funcionam dentro da conversa e utilizam o raciocínio do modelo para impulsionar ações. Parceiros iniciais como Canva, Coursera, Expedia e Zillow demonstraram como os usuários podem pedir uma playlist, criar um pôster ou pesquisar imóveis sem sair do ChatGPT[1]. O novo Apps SDK é construído sobre o Model Context Protocol (MCP), um padrão aberto que permite que modelos interajam com ferramentas externas e interfaces de usuário[2]. Este blog mergulha profundamente na arquitetura de aplicativos baseados em MCP, explica as capacidades do SDK, guia a construção de um aplicativo passo a passo, explora como os usuários descobrem e usam aplicativos, e discute considerações de privacidade e segurança. Ao longo, citamos documentação oficial e jornalismo respeitável para fundamentar a análise em fontes credíveis.

Entendendo o Protocolo de Contexto do Modelo (MCP)

Por Que Padrões Abertos Importam

O Protocolo de Contexto do Modelo é a base do SDK de Apps. De acordo com a documentação do desenvolvedor, toda integração do SDK de Apps usa um servidor MCP para expor ferramentas, lidar com autenticação e empacotar tanto dados estruturados quanto HTML que renderiza no ChatGPT[2]. MCP é um padrão aberto—qualquer pessoa pode implementar um servidor em qualquer linguagem e conectar um modelo como o GPT‑4 ou Codex. A natureza open‑source significa que não há bloqueio de fornecedor; o mesmo aplicativo pode teoricamente funcionar em qualquer plataforma de IA que implemente o protocolo. Essa abertura incentiva contribuições da comunidade e promove um ecossistema análogo à web inicial, onde padrões como HTTP permitiram sites interoperáveis.

Servidores, Ferramentas e Recursos

Um servidor MCP expõe uma ou mais ferramentas. Uma ferramenta define uma ação que o modelo pode chamar, como "criar um quadro kanban", "procurar casas" ou "gerar uma lista de reprodução". Cada ferramenta é descrita por um nome de máquina, um título amigável e um esquema JSON que informa ao modelo quais argumentos ele aceita. Quando o ChatGPT decide que a ferramenta deve ser invocada, ele envia uma chamada estruturada para o servidor. O servidor executa a lógica—seja consultando uma API, realizando um cálculo ou interagindo com um banco de dados—e então retorna uma resposta da ferramenta. Essa resposta inclui três campos:

structuredContent – dados visíveis para o modelo que descrevem o estado atual. Por exemplo, um quadro kanban pode incluir uma matriz de colunas e tarefas[3].
content – texto opcional que o assistente fala de volta para o usuário. Isso pode resumir o resultado ou instruir o usuário.
_meta – metadados ocultos não visíveis para o modelo. Desenvolvedores usam isso para armazenar IDs ou listas usadas em componentes de UI. Por exemplo, o exemplo do quadro usa um mapa tasksById em _meta para manter detalhes das tarefas sem expô-los ao modelo[4].

As ferramentas também podem se referir a recursos, como modelos HTML ou imagens, referenciando uma URL ui://. O servidor registra esses recursos durante a inicialização. A documentação alerta que, como os recursos são armazenados em cache pela infraestrutura da OpenAI, os desenvolvedores devem versioná-los incluindo um hash de build no nome do arquivo[5]. Caso contrário, os usuários podem ver uma interface desatualizada após implantações.

Conteúdo Estruturado vs. Metadados

A distinção entre structuredContent e _meta é crítica. De acordo com a documentação, structuredContent é visível para o modelo e é usado para hidratar o componente da interface do usuário; _meta é oculto do modelo e pode conter dados extras para a interface, como listas para menus suspensos[3]. Ao separar dados visíveis e ocultos, os desenvolvedores podem proteger informações sensíveis do modelo enquanto ainda renderizam interfaces ricas. Esse design também incentiva o compartilhamento mínimo de dados; apenas o necessário para realizar a tarefa é exposto, alinhando-se com os princípios de privacidade.

Autenticação e Sessões

Quando um usuário chama um aplicativo pela primeira vez, o servidor pode precisar autenticá-lo. O SDK de Apps suporta fluxos OAuth 2.1; os desenvolvedores especificam escopos e redirecionam os usuários para o provedor de identidade. Uma vez que o usuário concede consentimento, o aplicativo obtém um token e pode acessar os dados do usuário. O trabalho do servidor é gerenciar o estado da sessão, muitas vezes armazenando tokens em um banco de dados vinculado à conta do ChatGPT do usuário. Isso garante que chamadas subsequentes da ferramenta possam reutilizar a sessão sem solicitar novamente ao usuário.

Princípios de Segurança

A OpenAI enfatiza privilégio mínimo, consentimento explícito do usuário e defesa em profundidade[6]. Os aplicativos devem solicitar apenas as permissões mínimas necessárias, e os usuários devem autorizar explicitamente o compartilhamento de dados; o próprio modelo nunca deve adivinhar credenciais. A retenção de dados é limitada: o conteúdo estruturado permanece apenas enquanto o prompt do usuário está ativo, e os logs são redigidos antes de serem compartilhados com desenvolvedores[6]. O acesso à rede para componentes do aplicativo é restrito por uma política de segurança de conteúdo; iframes não podem acessar APIs arbitrárias do navegador, e todas as solicitações HTTP devem se originar do servidor em vez do cliente[7]. Isso previne scripts entre sites e exfiltração de tokens.

O Apps SDK: Construindo Aplicações Reais no ChatGPT

A Experiência do Desenvolvedor

O Apps SDK envolve o MCP em bibliotecas clientes idiomáticas (atualmente Python e TypeScript) e ferramentas de scaffolding. Quando você cria um aplicativo, define as ferramentas, registra modelos de UI e implementa a lógica do servidor. O servidor pode rodar na sua própria infraestrutura e usar qualquer framework (FastAPI, Express, etc.), mas deve implementar os endpoints do MCP. A OpenAI fornece servidores de desenvolvimento e um Inspetor MCP para testar chamadas localmente.

Os desenvolvedores projetam tanto a lógica quanto a interface do usuário. As UIs geralmente são escritas em React e compiladas em recursos estáticos. Elas são servidas dentro de um iframe isolado no ChatGPT. Dentro deste iframe, os desenvolvedores podem acessar um objeto global window.openai para interagir com o host. De acordo com o guia Construir uma UX personalizada, esta API fornece:

Globais – displayMode, maxHeight, theme e locale informam o componente sobre layout e estilo[8].
Payloads de Ferramentas – toolInput, toolOutput e widgetState permitem a leitura dos argumentos, resultados e estado persistente entre renderizações[8].
Ações – setWidgetState() salva o estado que persiste entre mensagens; callTool() aciona uma ação no servidor; sendFollowupTurn() envia um prompt de seguimento ao modelo; requestDisplayMode() solicita para ir para tela cheia ou modo picture-in-picture[8].
Eventos – o componente pode se inscrever em openai:set_globals quando o host atualiza o layout ou tema, e openai:tool_response quando uma chamada de ferramenta é resolvida[8].

Essas APIs permitem que os desenvolvedores construam componentes interativos ricos que permanecem sincronizados com o raciocínio do modelo. Por exemplo, se um usuário arrasta uma tarefa para uma nova coluna em um quadro kanban, o componente pode enviar um callTool para atualizar o servidor, persistir o novo estado e então retornar um novo structuredContent. Enquanto isso, o modelo vê apenas o estado do quadro em alto nível; a interface lida com detalhes como arrastar e soltar.

Registrando Ferramentas e Modelos

In the server code you register a tool and its template. For instance, in a TypeScript server you might write:

import { Tool, StructuredToolResponse } from "@openai/apps";

// Register UI template
server.registerResource("ui://kanban-board/abc123", buildHtml());

// Define tool schema
const createBoard: Tool = {
  name: "createKanbanBoard",
  description: "Create a new kanban board with given tasks and columns",
  inputSchema: z.object({
    title: z.string(),
    columns: z.array(z.object({ name: z.string() })),
    tasks: z.array(z.object({ name: z.string(), columnIndex: z.number() }))
  }),
  async execute(input, ctx): Promise<StructuredToolResponse> {
    // compute board state
    const columns = input.columns.map((col, i) => ({
      id: i,
      title: col.name,
      taskIds: input.tasks.filter(t => t.columnIndex === i).map((_t, idx) => idx)
    }));
    const tasksById = input.tasks.map((task, id) => ({ id, name: task.name }));
    return {
      content: `Created board '${input.title}'`,
      structuredContent: { title: input.title, columns },
      _meta: { tasksById, uiTemplate: "ui://kanban-board/abc123" }
    };
  }
};

The _meta field includes tasksById for hidden metadata and uiTemplate referencing the registered HTML. When ChatGPT receives this response, it will render the template with the structured content. The window.openai.toolOutput object in the component can then read the board data and display it.

Versioning and Caching

Como recursos como modelos de UI são armazenados em cache nos servidores da OpenAI, os desenvolvedores devem incluir um hash ou versão única no identificador ui://. Os documentos alertam que, se você implantar uma nova versão sem atualizar o caminho, os usuários podem continuar vendo a UI antiga devido ao cache[5]. Uma prática recomendada é incorporar o SHA do commit ou o ID da build na URL. Isso garante que cada implantação resulte em um recurso novo.

Persistência de Estado e Acompanhamentos

Componentes muitas vezes precisam persistir estado. Por exemplo, um aplicativo de playlist pode permitir que os usuários favoritem músicas; esses favoritos devem permanecer mesmo quando o usuário fizer outra pergunta. O método setWidgetState() armazena dados fora do structuredContent e persiste entre as interações[8]. O modelo não vê esse estado, garantindo privacidade.

Às vezes, um aplicativo precisa fazer uma pergunta de esclarecimento ao usuário. O método sendFollowupTurn() permite que o componente envie um novo prompt de volta ao ChatGPT, que aparecerá na transcrição como se o modelo tivesse feito a pergunta[8]. Isso é útil para fluxos de trabalho em várias etapas: por exemplo, um aplicativo de reserva de viagens pode perguntar “Quantas noites você vai ficar?” depois que o usuário selecionar um hotel.

Building Your First App: Step‑By‑Step Guide

In this section we will build a simple Task Tracker app that demonstrates the core concepts of the Apps SDK. The app will let a user create tasks and organise them into categories. We choose this example because it is generic, easy to extend and showcases structured content, metadata, custom UI and tool calls.

Set up the MCP Server

First install the TypeScript SDK and scaffolding tool:

npm install -g @openai/apps-generator
apps init task-tracker
cd task-tracker
npm install

This command scaffolds a project with a server, a React frontend and build scripts. The server uses Express and the @openai/apps library. Run npm run dev to start the development server; the project includes an MCP Inspector that opens in your browser and simulates ChatGPT calling your app.

Define the Tool

Open src/server.ts and define a tool called createTasks. The tool accepts an array of tasks and returns structured content grouping them by category. It also provides a summary in the content field.

import { Tool, StructuredToolResponse } from "@openai/apps";



export const createTasks: Tool = {
  name: "createTasks",
  description: "Create a list of tasks grouped by category",
  inputSchema: z.object({ tasks: z.array(z.object({ name: z.string(), category: z.string() })) }),
  async execute({ tasks }): Promise<StructuredToolResponse> {
    const categories = Array.from(new Set(tasks.map(t => t.category)));
    const grouped = categories.map(category => ({
      name: category,
      taskIds: tasks.filter(t => t.category === category).map((_, i) => i)
    }));
    const tasksById = tasks.map((task, id) => ({ id, name: task.name, category: task.category }));
    return {
      content: `Created ${tasks.length} tasks in ${categories.length} categories`,
      structuredContent: { categories: grouped },
      _meta: { tasksById, uiTemplate: "ui://task-tracker/1.0.0" }
    };
  }
};

server.registerResource("ui://task-tracker/1.0.0", fs.readFileSync(path.join(__dirname, "../dist/index.html"), "utf8"));
server.registerTool(createTasks);

Build the Custom UI

Next open src/frontend/App.tsx. This React component will read the structuredContent and display categories and tasks. It will also allow users to mark tasks as complete and persist that state using setWidgetState.

import { useEffect, useState } from "react";

declare global {
  interface Window {
    openai: any;
  }
}



export default function App() {
  const [complete, setComplete] = useState<{ [id: string]: boolean }>(() => window.openai.widgetState?.complete || {});
  const output = window.openai.toolOutput;
  const tasksById = output?._meta?.tasksById || [];
  const categories = output?.structuredContent?.categories || [];

  // persist completion state
  useEffect(() => {
    window.openai.setWidgetState({ complete });
  }, [complete]);

  return (
    <div className="task-tracker">
      {categories.map((cat: any, ci: number) => (
        <div key={ci} className="category">
          <h3>{cat.name}</h3>
          <ul>
            {cat.taskIds.map((tid: number) => (
              <li key={tid}>
                <label>
                  <input type="checkbox" checked={complete[tid]} onChange={() => setComplete(prev => ({ ...prev, [tid]: !prev[tid] }))} />
                  {tasksById[tid].name}
                </label>
              </li>
            ))}
          </ul>
        </div>
      ))}
    </div>
  );
}

This component uses window.openai.toolOutput to access the structuredContent and _meta fields. It stores completion state in widgetState so that checking a box persists even when the user continues the conversation. On subsequent tool calls, the component can fetch new tasks or update existing ones. This demonstrates how to combine model reasoning with client‑side interactions.

Testing and Iterating

Run npm run dev again and open the MCP Inspector. In the prompt area, type:

@task‑tracker create a list of tasks: buy milk in shopping, finish report in work, call mom in personal

The inspector will show the structured content and render the task list UI. You can check tasks off; the state persists across turns. You can then ask ChatGPT: “Remind me of my tasks later.” Because the model retains context, it can call the tool again, display the UI and summarise your progress.

How Users Discover and Use Apps

Named Mention and In‑Conversation Discovery

ChatGPT surfaces apps when it believes they can assist the user. There are two primary discovery modes. Named mention occurs when the user explicitly mentions the app name at the beginning of a prompt; in this case, the app will be surfaced automatically[9]. For instance, “@Spotify create a workout playlist” immediately invokes the Spotify integration. The user must place the app name at the start; otherwise the assistant may treat it as part of the conversation.

In‑conversation discovery happens when the model infers that an app could help based on context. The documentation explains that the model evaluates the conversation context, prior tool results and the user’s linked apps to determine which app might be relevant[9]. For example, if you are discussing travel plans, ChatGPT might suggest the Expedia app to book flights. The algorithm uses metadata like tool descriptions and keywords to match the conversation with potential actions[10]. Developers can improve discoverability by writing action‑oriented descriptions and clear UI component names.

Directory and Launcher

OpenAI plans to release an app directory where users can browse and discover new apps[10]. Each listing will include the app name, description, supported prompts and any onboarding instructions. Users can also access the launcher via the “+” button in chat; this shows a menu of available apps based on context. These entry points will help less technical users find and enable apps without memorising names.

Onboarding and Consent

Na primeira vez que um usuário ativa um app, o ChatGPT inicia um fluxo de integração. O modelo solicita que o usuário conecte sua conta (se necessário) e explica quais dados o app precisa. As diretrizes para desenvolvedores enfatizam que os apps devem respeitar a privacidade dos usuários, comportar-se de maneira previsível e ter políticas claras[11]. Os usuários devem conceder ou negar permissões explicitamente; não há acesso silencioso a dados. Uma vez conectado, o app pode permanecer vinculado para interações subsequentes, mas os usuários sempre têm a capacidade de desconectar e revogar permissões.

Privacidade, Segurança e Design Responsável

Princípios de Apps Confiáveis

As Diretrizes para Desenvolvedores de Apps da OpenAI definem vários princípios para garantir que o ecossistema permaneça seguro e confiável. Os aplicativos devem fornecer um serviço legítimo, ter uma política de privacidade clara e práticas de retenção de dados, além de cumprir as políticas de uso[11]. Eles devem minimizar a coleta de dados, evitar armazenar informações pessoais sensíveis e não compartilhar dados de usuários sem consentimento[12]. Os aplicativos devem se comportar de maneira previsível; não podem manipular o modelo para produzir conteúdo prejudicial ou enganoso.

Limites e Minimização de Dados

As diretrizes enfatizam que os aplicativos devem coletar apenas os dados essenciais para seu funcionamento e não devem solicitar ou armazenar dados sensíveis, como registros de saúde ou IDs governamentais[12]. O conteúdo estruturado enviado ao modelo não deve conter segredos; metadados ocultos não devem armazenar tokens de usuário ou detalhes privados. Os desenvolvedores devem implementar forte criptografia e armazenamento seguro para quaisquer tokens obtidos durante o OAuth. O servidor deve manter limites estritos entre as sessões dos usuários; dados de um usuário jamais devem vazar para o contexto de outro.

Medidas de Segurança no SDK

O Guia de Segurança e Privacidade descreve os mecanismos de defesa incorporados na plataforma. Ele enfatiza o princípio do menor privilégio e o consentimento explícito do usuário como princípios centrais[6]. A retenção de dados é limitada; os registros acessíveis aos desenvolvedores são editados para remover informações pessoalmente identificáveis, e o conteúdo estruturado é mantido apenas enquanto o prompt exigir[6]. O acesso à rede a partir do iframe é restrito pela política de segurança de conteúdo; buscas externas devem passar pelo servidor, prevenindo solicitações de origem cruzada não autorizadas[7]. A autenticação utiliza fluxos OAuth padrão do setor com tokens de curta duração. Os desenvolvedores são obrigados a implementar revisões de segurança, canais de relato de bugs e monitoramento de incidentes para manter a prontidão operacional[7].

Justiça e Adequação

Os aplicativos devem ser apropriados para um público amplo. As diretrizes proíbem aplicativos que fornecem conteúdo de longa duração, automação complexa ou anúncios. Por exemplo, um aplicativo não deve tentar entregar um vídeo de 30 minutos ou replicar uma rede social inteira dentro do ChatGPT. A plataforma incentiva interações sucintas que complementem o fluxo de conversa. Violações podem levar à rejeição ou remoção.

Oportunidades e Considerações

Um Novo Canal de Distribuição para Desenvolvedores

Ao abrir o ChatGPT para aplicativos de terceiros, a OpenAI se posiciona como uma "camada de intenção" entre usuários e serviços. Os desenvolvedores agora podem alcançar milhões de usuários através da interface de chat sem precisar criar aplicativos web ou móveis separados. Os aplicativos têm o potencial de reduzir o atrito: em vez de baixar um aplicativo ou visitar um site, os usuários apenas mencionam o serviço na conversa. Isso pode democratizar o acesso a ferramentas e nivelar o campo de jogo para pequenos desenvolvedores.

Parcerias iniciais mostram as possibilidades: os usuários podem assistir a palestras no Coursera enquanto fazem perguntas ao ChatGPT; criar cartazes no Canva; explorar opções de viagem no Expedia ou listagens imobiliárias no Zillow; gerar playlists do Spotify; ou diagramar ideias com o Figma[14][13]. Como os aplicativos funcionam dentro do chat, o modelo pode resumir, analisar e gerar recomendações, transformando conteúdo estático em lições interativas. Os aplicativos também oferecem múltiplos modos de exibição—cartões inline, tela cheia ou picture‑in‑picture—proporcionando flexibilidade para diferentes tarefas[15].

Transformando Expectativas dos Usuários

A capacidade de usar aplicativos sem mudar de contexto pode remodelar a forma como as pessoas interagem com os serviços. O ChatGPT se torna não apenas um chatbot, mas um sistema operacional universal para intenções. Como Casey Newton observou, isso nos move de lançar aplicativos distintos para simplesmente declarar o que queremos[16]. Alguns analistas comparam essa mudança ao lançamento da App Store ou do navegador: uma plataforma única que agrega funcionalidade e competição.

No entanto, essa transformação levanta questões sobre controle e poder. Se o ChatGPT determinar quais aplicativos exibir, ele poderá se tornar um porteiro. Newton alerta que um "grafo de IA" baseado nas preferências dos usuários pode criar riscos de privacidade mais sérios do que os das redes sociais[16]. Incentivos econômicos podem levar a um posicionamento ou classificação de aplicativos mediante pagamento. Desenvolvedores podem se sentir pressionados a projetar para o ChatGPT em vez de manter seu relacionamento com os usuários. É crucial que a plataforma permaneça transparente e justa para manter a confiança.

Implicações Regulamentares e Éticas

Como os aplicativos podem acessar dados pessoais — localização, contatos, métodos de pagamento — os reguladores podem examinar como os dados fluem através do ChatGPT. Os desenvolvedores devem cumprir as leis de privacidade, como o GDPR, mesmo que a plataforma ainda não esteja disponível na União Europeia[17]. A OpenAI prometeu controles de privacidade mais granulares e opções de monetização, incluindo um protocolo de comércio agentic que permitirá checkout instantâneo dentro do chat[18]. O sucesso desse ecossistema dependerá de segurança robusta, consentimento claro do usuário e modelos econômicos justos.

Direções Futuras e Pesquisa

O Apps SDK ainda está em pré-visualização e muitos recursos ainda precisam ser desenvolvidos. O roteiro do desenvolvedor inclui:

Fluxo de submissão e revisão – Atualmente, os desenvolvedores podem criar aplicativos, mas não podem listá-los publicamente. Um processo de revisão formal garantirá conformidade com diretrizes e confiança.
Compartilhamento de receita e monetização – A OpenAI sugeriu um protocolo de comércio agentico que poderia permitir que os usuários comprassem produtos diretamente no chat[18]. Isso levanta oportunidades para o comércio eletrônico, mas também questões sobre taxas, classificações e concorrência.
Ferramentas para desenvolvedores – Mais linguagens e frameworks, ferramentas de depuração aprimoradas e pipelines de implantação mais fáceis irão reduzir a barreira de entrada. A natureza de padrão aberto do MCP pode levar a implementações impulsionadas pela comunidade e provedores de hospedagem.
Interoperabilidade – Como o MCP é aberto, outras plataformas ou modelos poderiam adotá-lo. Isso poderia permitir um ecossistema de aplicativos cross-modelo, onde os desenvolvedores escrevem uma vez e executam em qualquer lugar. A pesquisa sobre padronização de protocolos de agentes e compartilhamento de contexto será importante.
Pesquisa de segurança – Avaliar como prevenir injeção de prompts, código malicioso ou uso indevido de dados do usuário continua sendo uma área importante de pesquisa. Artigos sobre ataques adversários contra aplicativos integrados com LLM informarão as melhores práticas e diretrizes.

Conclusão: Um novo SO em formação

A introdução de Apps no ChatGPT e do SDK de Apps baseado em MCP marca uma mudança significativa na forma como interagimos com o software. Ao trazer aplicativos de terceiros diretamente para a interface do chat, a OpenAI criou uma nova plataforma que mistura linguagem natural, raciocínio e interfaces interativas. O Protocolo de Contexto de Modelo fornece uma maneira aberta e padronizada para modelos chamarem ferramentas e renderizarem componentes; o SDK de Apps simplifica o desenvolvimento ao lidar com comunicação de servidor, integração de interface e gestão de estado. Exemplos passo a passo como o Rastreador de Tarefas demonstram como é fácil construir um aplicativo útil enquanto se mantém rigorosos limites de dados e privacidade.

No entanto, esta inovação traz responsabilidades. Os desenvolvedores devem seguir diretrizes que priorizam a privacidade, segurança e justiça do usuário[11][12]. Mecanismos de segurança como o menor privilégio e consentimento explícito protegem os usuários[6]. Ao mesmo tempo, observadores da indústria alertam que a plataforma pode criar novas formas de controle e riscos à privacidade[16]. À medida que o ecossistema amadurece, a transparência, padrões abertos e o engajamento da comunidade determinarão se a plataforma de aplicativos do ChatGPT se tornará uma camada transformadora e confiável para tarefas diárias.

[1] Últimas Notícias da Corrida Armamentista de IA: ChatGPT Agora Permite que Usuários Conectem com Spotify e Zillow em Conversas

https://www.forbes.com/sites/antoniopequenoiv/2025/10/06/openais-chatgpt-now-connects-with-third-party-apps-like-spotify-and-zillow-heres-the-latest-in-the-ai-arms-race/

[2] [3] [4] [5] Configure o seu servidor

https://developers.openai.com/apps-sdk/build/mcp-server

[6] [7] Segurança & Privacidade

https://developers.openai.com/apps-sdk/guides/security-privacy

[8] Crie uma UX personalizada

https://developers.openai.com/apps-sdk/build/custom-ux

[9] [10] Interação do Usuário

https://developers.openai.com/apps-sdk/concepts/user-interaction

[11] [12] Diretrizes para desenvolvedores de aplicativos

https://developers.openai.com/apps-sdk/app-developer-guidelines/