Primeros pasos

Este documento proporciona una guía introductoria para integrar los modelos de IA de Legit.Health utilizando la API JSON. Esta guía tiene como objetivo ayudar a sus equipos a prepararse para la implementación antes de consultar la documentación detallada de la API.

Legit.Health

info

Legit.Health es un dispositivo médico basado en la nube para dermatología que utiliza modelos de IA validados clínicamente para analizar imágenes de piel e información clínica estructurada.

Características principales

• Triaje y priorización mejorados

  • Vea qué casos son de alto riesgo o potencialmente malignos.
  • Decida quién necesita derivación urgente/de alta prioridad y asigne un nivel de prioridad claro.

• Apoyo al diagnóstico y razonamiento clínico

  • Utilice una lista clasificada de condiciones probables con probabilidades para enriquecer la evaluación clínica.
  • Comprenda si existe una lesión relevante, y si es de pigmentada o no pigmentada, de manera consistente.

• Monitoreo de enfermedades y tratamientos a lo largo del tiempo

  • Confíe en puntuaciones de severidad estándar (de imágenes o cuestionarios validados) para seguir la evolución de la enfermedad.
  • Realice un seguimiento del progreso del paciente a lo largo del tiempo y monitoree cómo su condición evoluciona con el tratamiento.

• Mejora de la atención basada en imágenes

  • Utilice retroalimentación sobre la calidad de imagen para saber cuándo una imagen es clínicamente utilizable.
  • Haga más confiables las imágenes remotas y capturadas por el paciente para la toma de decisiones.

Rol en la práctica clínica

La IA es una herramienta de apoyo a la decisión, no un sistema de diagnóstico autónomo. Todas las salidas deben ser revisadas e interpretadas por un profesional sanitario calificado, junto con el contexto clínico completo del paciente.

¿Cómo obtener acceso?

Para acceder a los endpoints protegidos de la API del Dispositivo Médico de Legit.Health, primero debe obtener sus credenciales de inicio de sesión (correo electrónico y contraseña) y luego usarlas para generar un token de acceso con tiempo limitado.

1. Contacte al equipo de atención al cliente de Legit.Health para iniciar su solicitud de acceso a la API.
2. El equipo de atención al cliente lo guiará a través del proceso de proporcionar la información requerida.
3. Una vez completado el proceso de configuración, recibirá un correo electrónico en la dirección proporcionada que contiene:
   • Su nombre de usuario (el correo electrónico que proporcionó).
   • Una contraseña generada por el sistema.
   • La URL base para acceder a los endpoints de la API de Legit.Health.

Descripción general de endpoints

Ejemplos de solicitudes de endpoint

Convención de URL

A lo largo de esta documentación, usaremos {base_url} para hacer referencia a la URL base y la versión de la API. Por ejemplo: {base_url}/login significa https://api.legit.health/version/login

Login

El endpoint de login se utiliza para autenticarse y obtener un token de acceso.

Python

import requests

path = "<base_url>" # the base url path provided during registration
url = f"{path}/login"
data = {
  "username": "<your_email>", # the email you provided
  "password": "<your_password>" # the password you have received in the email
}
headers = {"Content-Type": "application/x-www-form-urlencoded"}

resp = requests.post(url, data=data, headers=headers)
print(resp.json())
# JSON response example:
# {
#   "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
#   "token_type": "Access token",
#   "expires_in_minutes": "60"
# }

JavaScript

const path = "<base_url>"; // the base url path provided during registration

const formData = new URLSearchParams();
formData.append("username", "<your_email>"); // the email you provided
formData.append("password", "<your_password>"); // the password you have received in the email

fetch(`${path}/login`, {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded",
  },
  body: formData.toString(),
})
  .then((res) => res.json())
  .then((data) => {
    console.log(data);
    // JSON response example:
    // {
    //   "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    //   "token_type": "Access token",
    //   "expires_in_minutes": "60"
    // }
  })
  .catch((err) => console.error(err));

cURL

curl \
  "<base_url>/login" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "username=<your_email>&password=<your_password>"

Expiración de token

• Los tokens de acceso tienen tiempo limitado. Una vez que se alcanza expires_in_minutes, el token se vuelve inválido.
• Si recibe un error de autenticación o autorización debido a un token expirado o inválido, repita la solicitud /login con su correo electrónico y contraseña para obtener un nuevo token de acceso.

Apoyo al diagnóstico

El endpoint de apoyo al diagnóstico proporciona una lista clasificada de condiciones probables basada en imágenes de piel.

Imágenes de ejemplo

Puede encontrar imágenes de ejemplo para probar este endpoint en la sección Materiales. Estas imágenes incluyen varias condiciones dermatológicas y escenarios de prueba que puede utilizar para validar su integración.

Python

import requests
import base64

base_url = "<base_url>"  # the base url path provided during registration
url = f"{base_url}/diagnosis-support"

image_path = "<path_to_image>"  # Replace with the path to your image file (e.g., "lesion_image.jpg")
with open(image_path, "rb") as image_file:
    image_data = base64.b64encode(image_file.read()).decode('utf-8')

json_payload = {
    "payload": [{
        "contentAttachment": {
            "data": image_data
        }
    }]
}

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer <access_token>"  # obtained from /login endpoint
}

response = requests.post(url, json=json_payload, headers=headers)
result = response.json()

JavaScript

const baseUrl = "<base_url>"; // the base url path provided during registration
const fs = require("fs");

const image_path = "<path_to_image>"; // Replace with the path to your image file (e.g., "lesion_image.jpg")
const imageBuffer = fs.readFileSync(image_path);
const imageData = imageBuffer.toString("base64");

const json_payload = {
  payload: [
    {
      contentAttachment: {
        data: imageData,
      },
    },
  ],
};

const response = await fetch(`${baseUrl}/diagnosis-support`, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer <access_token>`, // obtained from /login endpoint
  },
  body: JSON.stringify(json_payload),
});

const result = await response.json();

cURL

# Replace <base64_encoded_image_data> with your Base64-encoded image data
# You can encode your image using: base64 -i <path_to_image>
curl -X POST "<base_url>/diagnosis-support" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '{
    "payload": [{
      "contentAttachment": {
        "data": "<base64_encoded_image_data>"
      }
    }]
  }'

Evaluación de severidad

Los endpoints de evaluación de severidad evalúan la severidad de la condición de un paciente utilizando sistemas de puntuación validados. Hay tres tipos de evaluación de severidad:

• Manual: Utiliza respuestas de cuestionarios proporcionadas por el clínico o paciente
• Automática local: Evaluación basada en IA a partir de imágenes de áreas específicas del cuerpo
• Automática global: Evaluación basada en IA a partir de imágenes de todo el cuerpo

Evaluación manual de severidad

El endpoint de evaluación manual de severidad calcula puntuaciones de severidad basadas en respuestas de cuestionarios.

Python

import requests

base_url = "<base_url>"  # the base url path provided during registration
url = f"{base_url}/severity-assessment/manual"

json_payload = {
    "bodySite": "armLeft", # for a complete list of available body site codes, refer to the Body Sites endpoint
    "knownCondition": {
        "conclusion": {
            "text": "psoriasis"  # plain text representation of the concept (local code that the concept was coded with).
        }
    },
    "scoringSystem": {
        "pure4": {  # for a complete list of available scoring systems, refer to the Questionnaires endpoint
            "questionnaireResponse": {
                "item": {
                    "question1": 1,
                    "question2": 0,
                    "question3": 0,
                    "question4": 1
                }
            }
        }
    }
}

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer <access_token>"  # obtained from /login endpoint
}

response = requests.post(url, json=json_payload, headers=headers)
result = response.json()

JavaScript

const base_url = "<base_url>"; // the base url path provided during registration
const url = `${base_url}/severity-assessment/manual`;

const json_payload = {
  bodySite: "armLeft", // for a complete list of available body site codes, refer to the Body Sites endpoint
  knownCondition: {
    conclusion: {
      text: "psoriasis", // plain text representation of the concept (local code that the concept was coded with).
    },
  },
  scoringSystem: {
    pure4: {
      // for a complete list of available scoring systems, refer to the Questionnaires endpoint
      questionnaireResponse: {
        item: {
          question1: 1,
          question2: 0,
          question3: 0,
          question4: 1,
        },
      },
    },
  },
};

const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer <access_token>`, // obtained from /login endpoint
  },
  body: JSON.stringify(json_payload),
});

const result = await response.json();

cURL

curl -X POST "<base_url>/severity-assessment/manual" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '{
    "bodySite": "armLeft",
    "knownCondition": {
      "conclusion": {
        "text": "psoriasis"
      }
    },
    "scoringSystem": {
      "pure4": {
        "questionnaireResponse": {
          "item": {
            "question1": 1,
            "question2": 0,
            "question3": 0,
            "question4": 1
          }
        }
      }
    }
  }'

Evaluación automática local de severidad

El endpoint de evaluación automática local de severidad utiliza IA para analizar imágenes y calcular puntuaciones de severidad para áreas específicas del cuerpo.

Python

import requests
import base64

base_url = "<base_url>"  # the base url path provided during registration
url = f"{base_url}/severity-assessment/automatic/local"

image_path = "<path_to_image>"  # Replace with the path to your image file (e.g., "lesion_image.jpg")
with open(image_path, "rb") as image_file:
    image_data = base64.b64encode(image_file.read()).decode('utf-8')

json_payload = {
    "payload": {
        "contentAttachment": {
            "data": image_data
        }
    },
    "bodySite": "armLeft",  # for a complete list of available body site codes, refer to the Body Sites endpoint
    "knownCondition": {
        "conclusion": {
            "text": "psoriasis"  # plain text representation of the concept (local code that the concept was coded with).
        }
    },
    "scoringSystem": {
        "apasi": {  # for a complete list of available scoring systems, refer to the Questionnaires endpoint
            "questionnaireResponse": {
                "item": {
                    "surface": 2
                }
            }
        }
    }
}

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer <access_token>"  # obtained from /login endpoint
}

response = requests.post(url, json=json_payload, headers=headers)
result = response.json()

JavaScript

const base_url = "<base_url>"; // the base url path provided during registration
const url = `${base_url}/severity-assessment/automatic/local`;
const fs = require("fs");

const image_path = "<path_to_image>"; // Replace with the path to your image file (e.g., "lesion_image.jpg")
const imageBuffer = fs.readFileSync(image_path);
const imageData = imageBuffer.toString("base64");

const json_payload = {
  payload: {
    contentAttachment: {
      data: imageData,
    },
  },
  bodySite: "armLeft", // for a complete list of available body site codes, refer to the Body Sites endpoint
  knownCondition: {
    conclusion: {
      text: "psoriasis", // plain text representation of the concept (local code that the concept was coded with).
    },
  },
  scoringSystem: {
    apasi: {
      // for a complete list of available scoring systems, refer to the Questionnaires endpoint
      questionnaireResponse: {
        item: {
          surface: 2,
        },
      },
    },
  },
};

const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer <access_token>`, // obtained from /login endpoint
  },
  body: JSON.stringify(json_payload),
});

const result = await response.json();

cURL

# Replace <base64_encoded_image_data> with your Base64-encoded image data
# You can encode your image using: base64 -i <path_to_image>
curl -X POST "<base_url>/severity-assessment/automatic/local" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer <access_token>" \
  -d '{
    "payload": {
      "contentAttachment": {
        "data": "<base64_encoded_image_data>"
      }
    },
    "bodySite": "armLeft",
    "knownCondition": {
      "conclusion": {
        "text": "psoriasis"
      }
    },
    "scoringSystem": {
      "apasi": {
        "questionnaireResponse": {
          "item": {
            "surface": 2
          }
        }
      }
    }
  }'

Evaluación automática global de severidad

El endpoint de evaluación automática global de severidad utiliza IA para analizar imágenes y calcular puntuaciones de severidad para todo el cuerpo.

Python

import requests
import base64

base_url = "<base_url>"  # the base url path provided during registration
url = f"{base_url}/severity-assessment/automatic/global"

image_folder = "<path_to_your_image_folder>"  # path to the folder where your images are stored

# List of all body sites
body_sites = [
    "armLeftBottom", "armLeftTop", "armRightBottom", "armRightTop",
    "faceFront", "faceLeft", "faceRight",
    "footLeft", "footRight",
    "handLeft", "handRight",
    "legsBack", "legsFront",
    "trunkBack", "trunkFront", "trunkLeft", "trunkRight"
]

# Build the items dictionary using a loop
items = {}
for body_site in body_sites:
    image_path = f"{image_folder}/{body_site}.jpg"
    with open(image_path, "rb") as image_file:
        image_data = base64.b64encode(image_file.read()).decode('utf-8')

    items[body_site] = {
        "payload": {
            "contentAttachment": {
                "data": image_data
            }
        }
    }

json_payload = {
    "knownCondition": {
        "conclusion": {
            "text": "vitiligo"  # plain text representation of the concept (local code that the concept was coded with).
        }
    },
    "scoringSystem": {
        "avasi": {
            "item": items
        }
    }
}

headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer <access_token>"  # obtained from /login endpoint
}

response = requests.post(url, json=json_payload, headers=headers)
result = response.json()

JavaScript

const base_url = "<base_url>"; // the base url path provided during registration
const url = `${base_url}/severity-assessment/automatic/global`;
const fs = require("fs");
const path = require("path");

const image_folder = "<path_to_your_image_folder>"; // path to the folder where your images are stored

// List of all body sites
const body_sites = [
  "armLeftBottom",
  "armLeftTop",
  "armRightBottom",
  "armRightTop",
  "faceFront",
  "faceLeft",
  "faceRight",
  "footLeft",
  "footRight",
  "handLeft",
  "handRight",
  "legsBack",
  "legsFront",
  "trunkBack",
  "trunkFront",
  "trunkLeft",
  "trunkRight",
];

// Build the items object using a loop
const items = {};
for (const body_site of body_sites) {
  const image_path = path.join(image_folder, `${body_site}.jpg`);
  const imageBuffer = fs.readFileSync(image_path);
  const imageData = imageBuffer.toString("base64");

  items[body_site] = {
    payload: {
      contentAttachment: {
        data: imageData,
      },
    },
  };
}

const json_payload = {
  knownCondition: {
    conclusion: {
      text: "vitiligo", // plain text representation of the concept (local code that the concept was coded with).
    },
  },
  scoringSystem: {
    avasi: {
      item: items,
    },
  },
};

const response = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer <access_token>`, // obtained from /login endpoint
  },
  body: JSON.stringify(json_payload),
});

const result = await response.json();

Solución de problemas

Asegúrese de que todas las peticiones y respuestas estén formateadas correctamente de acuerdo con la especificación de la API JSON. Para cualquier problema encontrado durante la integración o al generar PDF, consulte la sección de solución de problemas en la documentación oficial o póngase en contacto con nuestro equipo de apoyo para obtener ayuda.

Próximos pasos

Una vez que haya leído completamente esta página, puede proceder a la sección Endpoints para obtener información detallada sobre cada endpoint, incluidos los cuerpos de solicitud, estructuras de respuesta, parámetros y ejemplos de uso.