Cómo crear acciones personalizadas para GPTs en ChatGPT

Crear acciones personalizadas para GPTs y usarlos como Asistentes de Inteligencia Artificial capaces de interactuar con otras aplicaciones puede parecer una tarea compleja si no se tienen conocimientos de programación. Sin embargo, gracias a las capacidades y alcances de la IA, podremos desarrollar este tipo de acciones.

En este artículo explicaré el procedimiento general para crear acciones personalizadas para GPTs utilizando APIs, tomando como ejemplo la integración con Notion para crear páginas dinámicamente.

Cómo crear un GPT personalizado que interactúe con Notion sin saber programar

Conceptos clave para la creación de acciones para GPTs en ChatGPT

Para entender cómo funciona la integración entre aplicaciones, primero debes familiarizarte con algunos conceptos clave:

Configuración Inicial

Para poder desarrollar una integración con funciones personalizadas vas a tener que realizar un desarrollo local primero y después pasar un entorno de producción. Por lo que vas a necesitar realizar lo siguiente:

1. Instalación de Herramientas:

• Visual Studio Code: Para estructurar y modificar código.
• Python: Lenguaje de programación para crear nuestra API.

2. Preparación del Entorno de Trabajo:

• Crear una carpeta (ejemplo: «Tutorial»).
• Abrir Visual Studio Code y arrastrar la carpeta al área de trabajo.

3. Creación de un Entorno Virtual

Vamos Abrir una terminal de PowerShell en VS Code y vamos a copiar y pegar la siguiente secuencia de comandos para crear un entorno virtual.

• Para crear el entrono virtual:

python -m venv nombre_del_entorno 
Ej: python -m venv notion-gpt

• Ir a la carpeta de scripts en el entorno virtual:

cd notion-gpt\scripts

• Activar el entorno virtual:

.\activate

• Identificarás que tu entorno virtual está activo porque el nombre que usaste para crear al entorno aparece al principio.

• Si encuentras algún problema al activar el entorno virtual, es posible que debas cambiar la política de ejecución en PowerShell para permitir scripts. Esto se puede hacer con el siguiente comando en PowerShell como administrador:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Si llegas a encontrar algún otro problema simplemente cópialo y dile a ChatGPT que te ayude a solucionarlo. Dale contexto y específica que estás usando VScode. Esa será la manera de solucionar los posibles problemas que nos encontremos de aquí en adelante.

Ya una vez tenemos configurado nuestro entorno, vamos a ChatGPT y le damos nuestra idea para una API.

Vamos a comenzar con algo simple, el objetivo es generar un código que haga a nivel general lo que estamos buscando. Una vez funcione implementaremos funciones más detalladas y por último realizamos verificaciones de seguridad, ¡con la ayuda de IA obviamente!

Pasos para crear acciones para GPTs en ChatGPT

Procedimiento general

A grandes rasgos, estos son los pasos para crear una acción personalizada con APIs para GPTs:

1. Crear la API en Python que se conectará con el servicio/aplicación de destino (en nuestro ejemplo Notion).
2. Prueba la AP y corrige los errores.
3. Subir la API a un servidor como Replit para que sea accesible públicamente.
4. Crear el archivo YAML que utilizará ChatGPT para comunicarse con nuestra API.
5. Configurar la acción en ChatGPT apuntando a nuestra API.

Veamos esto con más detalle.

1. Genera el código base de la API en Python

El primer paso es usar nuestro GPT personalizado (API For GPTs) para que te proporcione el código inicial de la API usando python como lenguaje de programación y Flask como Framework.

ChatGPT puede ayudarnos a generar una plantilla inicial con el código necesario. Simplemente debemos indicarle los detalles como el servicio destino (en nuestro caso Notion) y la funcionalidad deseada (crear páginas).

Una vez generado el código, configuramos nuestro entorno de desarrollo local usando VScode e instalamos las dependencias necesarias para su ejecución.

También configuraremos credenciales de ser necesarias en un archivo (.env) y crearemos un (JSON) de ejemplo para estructurar las solicitudes.

En nuestro ejemplo, debemos configurar el Token de Notion e ID de página, revisar permisos, etc. Una vez tengas la base, deberás configurar las variables de entorno (Notion Token y Page ID) en un archivo (.env) para permitir el acceso a tu cuenta de Notion. Nunca compartas estos datos, ya que permitirían el control total sobre tus páginas.

Una vez realizado esto vamos a ejecutar la API de manera local para obtener la url de nuestro servidor local. Y le pediremos a nuestro GPT el comando PowerShell para ejecutar el programa dándole la URL del servidor y el nombre del archivo JSON de ejemplo.

Comando PowerShell de ejemplo:

Invoke-RestMethod -Uri "http://127.0.0.1:5000/create-page" -Method Post -ContentType "application/json" -InFile "crear.json"

2. Corrige errores y prueba la API

Es normal que la API genere errores al ejecutarse. En este paso deberás copiar los mensajes de error y pedirle ayuda a ChatGPT para solucionar los problemas.

Valida de forma iterativa que la API funcione correctamente antes de continuar con los siguientes pasos.

Te recomendamos usar el siguiente Prompt:

Tengo el siguiente <error> al momento de ejecutar mi comando PowerShell, en mi <código API>.
Verifica que todo esté bien y soluciona el <error>.
<error> 
Pegar aquí el mensaje de error de la terminal 
</error>
<código API> 
Pegar aquí el código API 
</código API>

3. Pública la API con Replit

Una vez la API funcione sin errores, deberás publicarla para tener una URL estable para hacer peticiones. Puedes usar Replit para publicar la API de forma gratuita.

Replit es un IDE online muy fácil de usar para proyectos de programación. Solo necesitas crear una cuenta, copiar tu código en Python y configurar las variables de entorno de forma segura.

Instala las dependencias necesarias usando la sección de Packages en las herramientas de Replit y configura los valores del archivo (.env) en un archivo Secrets de Replit.

4. Crea el código YAML de integración

Ahora que la API está publicada, es momento de crear la integración con ChatGPT. Para este caso usaremos el siguiente GPT (YAML FOR GPTs) para que te genere el código YAML necesario.

Este código YAML definirá la URL de la API y la estructura de las solicitudes para crear contenido en Notion.

Te recomendamos usar el siguiente Prompt:

Crea un código YAML para la siguiente <api>, la URL del servidor es [URL], Tambien te dejo un <JSON de ejemplo>
<api> 
Pegar aquí el código de tu API 
</api>
<JSON de ejemplo> 
Pegar aquí el código de tu archivo JSON de ejemplo 
</JSON de ejemplo>

5. Configura la acción personalizada

Finalmente, deberás incluir el código YAML de integración dentro de la sección de Acciones Personalizadas de tu ChatGPT. Esto permitirá que, al enviar una solicitud, se ejecute un flujo completo:

1. Petición desde ChatGPT hacia la API
2. Procesamiento de la API
3. Creación de contenido en Notion
4. Respuesta de ChatGPT confirmando la acción

Si al integrar el código YAML generado anteriormente encuentras algún error, cópialo y pégalo en el anterior GPT y te ayudará a solucionarlo.

¡Y ya estaría lista la integración! Ahora ChatGPT podrá crear páginas y contenidos en Notion automáticamente según tus comandos de voz.

Consideraciones de Seguridad al Usar Replit y Crear APIs con ChatGPT

Cuando se trata de almacenar y gestionar APIs, especialmente en plataformas como Replit, y al crear APIs con ChatGPT, es crucial considerar múltiples aspectos de seguridad para proteger tanto la integridad del sistema como la privacidad y seguridad de los datos. Aquí presentamos algunas consideraciones clave:

1. Manejo de Claves y Tokens de API:

• Nunca exponga claves de API en el código fuente: Almacénelas en variables de entorno o utilice secretos gestionados.
• Rotación regular de claves: Cambie las claves de API periódicamente para reducir el riesgo de accesos no autorizados.

2. Control de Acceso y Autenticación:

• Implementar autenticación fuerte: Utilice mecanismos como OAuth para controlar el acceso a la API.
• Restringir el acceso: Asegúrese de que solo los usuarios y servicios autorizados puedan acceder a su API.

3. Validación y Saneamiento de Datos:

• Validar todas las entradas: Nunca confíe en la entrada del usuario; siempre valide para evitar inyecciones SQL y otros ataques.
• Sanear los datos recibidos: Asegúrese de que los datos ingresados no contengan elementos dañinos.

4. Gestión de Errores y Registro de Actividades:

• Manejo cuidadoso de errores: Evite exponer detalles sensibles a través de mensajes de error.
• Registro y monitoreo: Mantenga registros detallados de las actividades de la API para detectar y responder a actividades sospechosas.

5. Seguridad en Replit:

• Mantener la privacidad del proyecto: Configure su proyecto en Replit como privado para evitar exposiciones accidentales, para esto debe actualizar su cuenta a una de pago.
• Uso de ambientes secretos en Replit: Almacene claves API y tokens en los secretos de Replit en lugar de en el código directamente.

6. Seguridad en la Comunicación:

• Implementar HTTPS: Asegúrese de que todas las comunicaciones con su API sean a través de HTTPS para prevenir ataques de intermediarios.
• Limitar solicitudes: Implemente limitaciones en la tasa de solicitudes para proteger su API de ataques de denegación de servicio.

7. Actualizaciones y Mantenimiento:

• Mantener el software actualizado: Regularmente actualice todas las dependencias y plataformas utilizadas.
• Pruebas de seguridad periódicas: Realice auditorías y pruebas de seguridad periódicas para identificar y mitigar vulnerabilidades.

8. Consideraciones Específicas al Usar ChatGPT para Crear APIs:

• Revisión del código generado: Asegúrese de revisar y entender el código generado por ChatGPT, ya que puede contener vulnerabilidades o ineficiencias. Puede pedirle a ChatGPT que le explique el código y cree comentarios para ayudarlo a comprender su lógica.
• Limitar las capacidades de GPT: Defina claramente las capacidades y limitaciones del GPT para evitar comportamientos no deseados o riesgosos.

Código generado accion GPT – Notion

A continuación, te dejamos el código generado en la conversación con ChatGPT en una conversación de 23 mensajes.

Código API

from flask import Flask, request, jsonify
from notion_client import Client
from dotenv import load_dotenv
import os

app = Flask(__name__)

# Carga las variables de entorno
load_dotenv()

# Inicializa el cliente de Notion
notion_token = os.environ.get("NOTION_TOKEN")
notion = Client(auth=notion_token)


@app.route('/create-page', methods=['POST'])
def create_page():

  # Obtiene los datos
  data = request.json

  # Extrae el título y contenido
  page_title = data.get("title")
  content_blocks = data.get("content")

  if not page_title:
    return jsonify({"error": "No title"}), 400

  if not content_blocks or not isinstance(content_blocks, list):
    return jsonify({"error": "Invalid content format"}), 400

  parent_page_id = os.environ.get("NOTION_PAGE_ID")
  if not parent_page_id:
    return jsonify({"error": "No parent page ID"}), 500

  try:
    new_page = notion.pages.create(
        parent={"page_id": parent_page_id},
        properties={"title": [{
            "text": {
                "content": page_title
            }
        }]},
        children=content_blocks)
    return jsonify(new_page), 200

  except Exception as e:
    return jsonify({"error": str(e)}), 500


if __name__ == "__main__":
  app.run(host="0.0.0.0", port=80)

.env

NOTION_TOKEN=Internal Integration Secret
NOTION_PAGE_ID=Id de la pagina

JSON de ejemplo

{
    "title": "Mi Página de Prueba",
    "content": [
      {
        "type": "heading_1",
        "heading_1": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Encabezado 1"
              }
            }
          ]
        }
      },
      {
        "type": "heading_2",
        "heading_2": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Encabezado 2"
              }
            }
          ]
        }
      },
      {
        "type": "numbered_list_item",
        "numbered_list_item": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Elemento 1 de lista numerada"
              }
            }
          ]
        }
      },
      {
        "type": "bulleted_list_item",
        "bulleted_list_item": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Elemento 1 de lista con viñetas"
              }
            }
          ]
        }
      },
      {
        "type": "to_do",
        "to_do": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Tarea pendiente 1"
              }
            }
          ],
          "checked": false
        }
      },
      {
        "type": "image",
        "image": {
          "type": "external",
          "external": {
            "url": "https://mistercontenidos.com/wp-content/uploads/2023/11/como-crear-un-GPT-en-chatGPT.webp"
          }
        }
      },
      {
        "type": "quote",
        "quote": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Una cita inspiradora"
              }
            }
          ]
        }
      },
      {
        "type": "paragraph",
        "paragraph": {
          "rich_text": [
            {
              "type": "text",
              "text": {
                "content": "Un párrafo de texto"
              }
            }
          ]
        }
      }
    ]
  }

Dependencias necesarias

pip install Flask notion-client python-dotenv

YAML de usado en ChatGPT

openapi: "3.1.0"
info:
  version: "1.0.0"
  title: Asistente Notion API
  description: API para interactuar con Notion creando páginas.
servers:
  - url: #link del servidor

paths:
  /create-page:
    post:
      summary: Crea una página en Notion
      operationId: createPage
      description: Crea una nueva página en Notion con el título y contenido proporcionados.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - title
                - content
              properties:
                title:
                  type: string
                  description: Título de la página de Notion.
                content:
                  type: array
                  description: Bloques de contenido de la página.
                  items:
                    type: object
                    properties:
                      type:
                        type: string
                        description: Tipo de bloque de contenido.
                      heading_1:
                        $ref: '#/components/schemas/Heading'
                      heading_2:
                        $ref: '#/components/schemas/Heading'
                      numbered_list_item:
                        $ref: '#/components/schemas/List'
                      bulleted_list_item:
                        $ref: '#/components/schemas/List'
                      to_do:
                        $ref: '#/components/schemas/ToDo'
                      image:
                        $ref: '#/components/schemas/Image'
                      quote:
                        $ref: '#/components/schemas/Quote'
                      paragraph:
                        $ref: '#/components/schemas/Paragraph'
      responses:
        '200':
          description: Página creada con éxito en Notion.
          content:
            application/json:
              schema:
                type: object
                properties:
                  id:
                    type: string
                    description: ID de la página creada.
        '400':
          description: Datos de entrada inválidos.
        '500':
          description: Error del servidor o de la API de Notion.

components:
  schemas:
    Heading:
      type: object
      properties:
        rich_text:
          type: array
          items:
            $ref: '#/components/schemas/Text'

    List:
      type: object
      properties:
        rich_text:
          type: array
          items:
            $ref: '#/components/schemas/Text'

    ToDo:
      type: object
      properties:
        rich_text:
          type: array
          items:
            $ref: '#/components/schemas/Text'
        checked:
          type: boolean

    Image:
      type: object
      properties:
        type:
          type: string
          enum: [external]
        external:
          type: object
          properties:
            url:
              type: string
              format: uri

    Quote:
      type: object
      properties:
        rich_text:
          type: array
          items:
            $ref: '#/components/schemas/Text'

    Paragraph:
      type: object
      properties:
        rich_text:
          type: array
          items:
            $ref: '#/components/schemas/Text'

    Text:
      type: object
      properties:
        type:
          type: string
          enum: [text]
        text:
          type: object
          properties:
            content:
              type: string

Consideraciones finales al crear acciones para GPTs

Al crear este tipo de integraciones, ten en cuenta:

• No compartas tus tokens o API keys públicamente.
• Válida exhaustivamente antes de usar en producción.
• Revisa los límites de uso de las APIs para no saturarlas.
• Actualiza periódicamente tu código para detectar vulnerabilidades.

Aunque el proceso lleva tiempo, gran parte del trabajo lo realizará la Inteligencia artificial. ¡Pon en práctica estos pasos y crea tus propias acciones para tus GPTs personalizados!

Crear acciones personalizadas para ChatGPT utilizando APIs nos permite extender enormemente sus capacidades y automatizar flujos de trabajo. Los pasos vistos en este artículo sirven como una plantilla que podemos adaptar a cualquier servicio o aplicación destino.

También puede ser de tu interés:

• Cómo usar GEMINI la nueva IA de Google.
• Guia para crear GPTs desde 0 en ChatGPT.