Upload 5 files

notebooks/01-extraccion-de-datos-ner-openai-api.ipynb

@@ -0,0 +1,1161 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 0. Preparación del notebook e inicialización del cliente de OpenAI API"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key: sk-proj-****************************************************************************************************************************************************-amA_5sA\n",
+      "Cliente inicializado como <openai.OpenAI object at 0x0000011B3A4D3790>\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import json\n",
+    "import textwrap\n",
+    "from datetime import datetime\n",
+    "from openai import OpenAI\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv(\"../../../../../../../apis/.env\")\n",
+    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "unmasked_chars = 8\n",
+    "masked_key = api_key[:unmasked_chars] + '*' * (len(api_key) - unmasked_chars*2) + api_key[-unmasked_chars:]\n",
+    "print(f\"API key: {masked_key}\")\n",
+    "client = OpenAI(api_key=api_key)\n",
+    "print(\"Cliente inicializado como\",client)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Zero-shot named entity recognition"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Empezamos con un caso sencillo extrayendo un texto del CV de ejemplo y sin especificar esquema para el diccionario de datos json:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"empresa\": \"Mercadona\",\n",
+      "  \"puesto\": \"Vendedor/a de puesto de mercado\"\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "text = \"Vendedor/a de puesto de mercado - Mercadona\"\n",
+    "# System prompt para reconocimiento de entidades nombradas (NER) de nombres de compañías y títulos de puestos de trabajo\n",
+    "ner_pre_prompt = (\n",
+    "  \"Eres un procesador de currículos vitae que extrae nombres de \"\n",
+    "  \"compañías/empresas y títulos de puestos de trabajo. Usa formato json en la salida \"\n",
+    "  'con las claves \"empresa\" y \"puesto\".'\n",
+    ")\n",
+    "\n",
+    "response = client.chat.completions.create(\n",
+    "      model=\"gpt-4o-mini\",\n",
+    "      response_format={\"type\": \"json_object\"}, # De momento no facilitamos esquema. Lo probaremos más adelante.\n",
+    "      messages=[\n",
+    "        {\"role\": \"system\", \"content\": ner_pre_prompt},\n",
+    "        {\"role\": \"user\", \"content\": text}\n",
+    "      ]\n",
+    "    )\n",
+    "generated_content = response.choices[0].message.content\n",
+    "print(generated_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Ejemplo de reconocimiento de entidades nombradas en un currículo completo. Hemos utilizado un CV de ejemplo no incluido en el repositorio. Para ejecutar el siguiente bloque, es necesario facilitar una ruta válida a un currículo:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Candidato: Mohamed van der Poel Mendieta\n",
+      "Último Puesto Comercial de automoviles\n",
+      "Última formación reglada FP 1 / Técnico medio\n",
+      "3\n",
+      "Idioma EspañolInglésFr ...\n"
+     ]
+    }
+   ],
+   "source": [
+    "cv_sample_path = '../../ejemplos_cvs/cv_sample.txt' # Ruta al fichero de texto con un currículo de ejemplo \n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "print(cv_text[:150],\"...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Inferencia de entidades nombradas \"empresa\" y \"puesto\" con un modelo de OpenAI (elegimos gpt-4o-mini para reducir los costes y dado que esto sólo es una sencilla prueba de concepto)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"experiencias\": [\n",
+      "    {\n",
+      "      \"empresa\": \"Autónomo\",\n",
+      "      \"puesto\": \"Comercial de automoviles\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"Mercadona\",\n",
+      "      \"puesto\": \"Vendedor/a de puesto de mercado\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"AGRISOLUTIONS\",\n",
+      "      \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "      \"puesto\": \"Camarero/a de barra\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"ZEREGUIN ZERBITZUAK\",\n",
+      "      \"puesto\": \"Limpieza industrial\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"Bellota Herramientas\",\n",
+      "      \"puesto\": \"Personal de mantenimiento\"\n",
+      "    }\n",
+      "  ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = client.chat.completions.create(\n",
+    "      model=\"gpt-4o-mini\",\n",
+    "      response_format={\"type\": \"json_object\"},\n",
+    "      messages=[\n",
+    "        {\"role\": \"system\", \"content\": ner_pre_prompt},\n",
+    "        {\"role\": \"user\", \"content\": cv_text}\n",
+    "      ]\n",
+    "    )\n",
+    "generated_content = response.choices[0].message.content\n",
+    "print(generated_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Procesamiento de fechas"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vamos a intentar extraer también las fechas para cada puesto de trabajo. Para ello, añadiremos algunas indicaciones adicionales en relación a los posibles formatos de entrada y al formato de salida. En cuanto a las entradas, asumimos que cada CV puede tener formatos muy distintos para esta información. Para las salidas, queremos un formato que nos facilite posteriormente realizar cálculos con fechas como la duración total, antigüedad con respecto a fecha actual, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eres un procesador de currículos vitae que extrae títulos de puestos de trabajo, nombres de la\n",
+      "empresa, y períodos de los mismos. Usa formato json en la salida con las claves \"empresa\", \"puesto\"\n",
+      "y \"periodo\". Para el período, contempla cualquier formato de fecha o rango de fechas incluido en el\n",
+      "texto. Un ejemplo de formato de fecha en la entrada es \"Octubre 2023 / Marzo 2024\". Otros ejemplos\n",
+      "de formatos de fecha son \"10/2023 - 03/2024\", \"Oct 2023 - Mar 2024\", etc. El contenido para la clave\n",
+      "\"período\" debe ser un string con dos elementos en formato YYYYMM separados por un guion, por ejemplo\n",
+      "\"202310-202403\", o uno en caso de no identificarse fecha de fin.\n"
+     ]
+    }
+   ],
+   "source": [
+    "explicacion_fechas = (\n",
+    "    'Para el período, contempla cualquier formato de fecha o rango de fechas incluido en el texto. '\n",
+    "    'Un ejemplo de formato de fecha en la entrada es \"Octubre 2023 / Marzo 2024\". Otros ejemplos de '\n",
+    "    'formatos de fecha son \"10/2023 - 03/2024\", \"Oct 2023 - Mar 2024\", etc. '\n",
+    "    'El contenido para la clave \"período\" debe ser un string con dos elementos en formato YYYYMM '\n",
+    "    'separados por un guion, por ejemplo \"202310-202403\", o uno en caso de no identificarse fecha de fin.'\n",
+    "    )\n",
+    "\n",
+    "ner_pre_prompt = (\n",
+    "  'Eres un procesador de currículos vitae que extrae títulos de puestos de trabajo, '\n",
+    "  'nombres de la empresa, y períodos de los mismos. Usa formato json en la salida '\n",
+    "  f'con las claves \"empresa\", \"puesto\" y \"periodo\". {explicacion_fechas}'\n",
+    ")\n",
+    "wrapped_ner_pre_prompt = textwrap.fill(ner_pre_prompt, width=100)\n",
+    "print(wrapped_ner_pre_prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Autónomo\",\n",
+      "            \"puesto\": \"Comercial de automoviles\",\n",
+      "            \"periodo\": \"202401-202402\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "            \"periodo\": \"202310-202403\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"AGRISOLUTIONS\",\n",
+      "            \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "            \"periodo\": \"202001-202401\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "            \"puesto\": \"Camarero/a de barra\",\n",
+      "            \"periodo\": \"202303-202309\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"ZEREGUIN ZERBITZUAK\",\n",
+      "            \"puesto\": \"limpieza industrial\",\n",
+      "            \"periodo\": \"202012-202305\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Bellota Herramientas\",\n",
+      "            \"puesto\": \"Personal de mantenimiento\",\n",
+      "            \"periodo\": \"202005-202011\"\n",
+      "        }\n",
+      "    ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = client.chat.completions.create(\n",
+    "      model=\"gpt-4o-mini\",\n",
+    "      response_format={\"type\": \"json_object\"},\n",
+    "      messages=[\n",
+    "        {\"role\": \"system\", \"content\": ner_pre_prompt},\n",
+    "        {\"role\": \"user\", \"content\": cv_text}\n",
+    "      ]\n",
+    "    )\n",
+    "generated_content = response.choices[0].message.content\n",
+    "print(generated_content)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401-202402</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202403</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "\n",
+       "         periodo  \n",
+       "0  202401-202402  \n",
+       "1  202310-202403  \n",
+       "2  202001-202401  \n",
+       "3  202303-202309  \n",
+       "4  202012-202305  \n",
+       "5  202005-202011  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Convertimos el texto en un objeto JSON\n",
+    "json_object = json.loads(generated_content)\n",
+    "# Convertimos a Pandas dataframe para realizar operaciones\n",
+    "# Aún no hemos especificado el esquema completo (a veces puede ser que el modelo nos dé \"experiencias\" en lugar de \"experiencia\")\n",
+    "df = pd.DataFrame(json_object[\"experiencia\"]) \n",
+    "display(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Antes de desarrollar el código para la extracción y tratamiento de fechas, vamos a comprobar si el modelo es capaz de procesar correctamente un puesto sin fecha de fin en el período. Vamos a eliminar la fecha de fin en el puesto \"comercial de automóviles\" y guardarlo en '../../ejemplos_cvs/cv_sample_2.txt' (esta ruta no está incluida en el repositorio)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### Ejemplo original ###\n",
+      "...\n",
+      "Sexo Hombre\n",
+      "Experiencia\n",
+      "Enero 2024 / Febrero 2024\n",
+      "Comercial de automoviles - Autónomo\n",
+      "...\n",
+      "\n",
+      "### Ejemplo modificado ###\n",
+      "...\n",
+      "Sexo Hombre\n",
+      "Experiencia\n",
+      "Enero 2024\n",
+      "Comercial de automoviles - Autónomo\n",
+      "...\n"
+     ]
+    }
+   ],
+   "source": [
+    "cv_sample_2_path = '../../ejemplos_cvs/cv_sample_2.txt'\n",
+    "with open(cv_sample_2_path, 'r') as file:\n",
+    "    cv_text_2 = file.read()\n",
+    "print(f\"### Ejemplo original ###\\n...\\n{cv_text[301:386]}\\n...\")\n",
+    "print(f\"\\n### Ejemplo modificado ###\\n...\\n{cv_text_2[301:371]}\\n...\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Volvemos a pedir la inferencia con el CV modificado:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{\n",
+      "  \"experiencia\": [\n",
+      "    {\n",
+      "      \"empresa\": \"Autónomo\",\n",
+      "      \"puesto\": \"Comercial de automoviles\",\n",
+      "      \"periodo\": \"202401\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"Mercadona\",\n",
+      "      \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "      \"periodo\": \"202310-202404\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"AGRISOLUTIONS\",\n",
+      "      \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "      \"periodo\": \"202001-202401\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "      \"puesto\": \"Camarero/a de barra\",\n",
+      "      \"periodo\": \"202303-202309\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"ZEREGUIN ZERBITZUAK\",\n",
+      "      \"puesto\": \"limpieza industrial\",\n",
+      "      \"periodo\": \"202012-202305\"\n",
+      "    },\n",
+      "    {\n",
+      "      \"empresa\": \"Bellota Herramientas\",\n",
+      "      \"puesto\": \"Personal de mantenimiento\",\n",
+      "      \"periodo\": \"202005-202011\"\n",
+      "    }\n",
+      "  ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "response = client.chat.completions.create(\n",
+    "      model=\"gpt-4o-mini\",\n",
+    "      response_format={\"type\": \"json_object\"},\n",
+    "      messages=[\n",
+    "        {\"role\": \"system\", \"content\": ner_pre_prompt},\n",
+    "        {\"role\": \"user\", \"content\": cv_text_2} # Sin fecha de fin en la última experiencia\n",
+    "      ]\n",
+    "    )\n",
+    "generated_content = response.choices[0].message.content\n",
+    "print(generated_content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Vemos que el modelo gpt-4o-mini parece suficientemente solvente procesando e interpretando datos no estructurados como fechas. En un caso de uso real en el que dispongamos de muchos ficheros de entrada, podríamos entrenar un modelo de \"named entity recognition\" más sofisticado para asegurar mayor precisión. \n",
+    "\n",
+    "<br> A continuación, procedemos a tratar las fechas para definir un parámetro de duración del puesto de trabajo: "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "\n",
+       "         periodo  \n",
+       "0         202401  \n",
+       "1  202310-202404  \n",
+       "2  202001-202401  \n",
+       "3  202303-202309  \n",
+       "4  202012-202305  \n",
+       "5  202005-202011  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Convertimos el texto en un objeto JSON\n",
+    "json_object = json.loads(generated_content)\n",
+    "# Convertimos a Pandas dataframe para realizar operaciones\n",
+    "df_experiencia = pd.DataFrame(json_object[\"experiencia\"])\n",
+    "display(df_experiencia)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-08</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  \n",
+       "0         202401  2024-01-01  2024-12-08        11  \n",
+       "1  202310-202404  2023-10-01  2024-04-01         6  \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48  \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6  \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29  \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Función para procesar el período\n",
+    "def split_periodo(periodo):\n",
+    "    dates = periodo.split('-')\n",
+    "    start_date = datetime.strptime(dates[0], \"%Y%m\")\n",
+    "    if len(dates) > 1:\n",
+    "        end_date = datetime.strptime(dates[1], \"%Y%m\")\n",
+    "    else:\n",
+    "        end_date = datetime.now()\n",
+    "    return start_date, end_date\n",
+    "\n",
+    "df_experiencia[['fec_inicio', 'fec_final']] = df_experiencia['periodo'].apply(lambda x: pd.Series(split_periodo(x)))\n",
+    "\n",
+    "# Formateamos las fechas para mostrar mes, año, y el primer día del mes (dado que el día es irrelevante y no se suele especificar)\n",
+    "df_experiencia['fec_inicio'] = df_experiencia['fec_inicio'].dt.date\n",
+    "df_experiencia['fec_final'] = df_experiencia['fec_final'].dt.date\n",
+    "\n",
+    "# Añadimos una columna con la duración en meses\n",
+    "df_experiencia['duracion'] = df_experiencia.apply(\n",
+    "    lambda row: (row['fec_final'].year - row['fec_inicio'].year) * 12 + \n",
+    "                row['fec_final'].month - row['fec_inicio'].month, \n",
+    "    axis=1\n",
+    ")\n",
+    "\n",
+    "display(df_experiencia)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_experiencia.to_pickle('../pkl/df_experiencia.pkl') # Guardamos pickle para usarlo en el siguiente notebook"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. NER con sequema para \"structured output\" y llamada a función"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Explicar lo que necesitamos en el prompt y poner \"json_object\" en \"response_format\" parece más suficiente para obtener buenos resultados la mayoría de las veces. Sin embargo, nos podemos encontrar con problemas como, por ejemplo, que el modelo no siempre nos dé la misma palabra como clave de primer nivel (a veces puede poner \"experiencia\", otras veces \"experiencias\", \"roles\"...). Se podría intentar explicar esto con lenguaje natural en el prompt, pero es más sencillo definir un esquema y definirlo como función.\n",
+    "\n",
+    "Sin embargo, para asegurar que el modelo siempre responda con un formato consistente, podemos definir un esquema:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Eres un procesador de currículos vitae que extrae títulos de puestos de trabajo, nombres de la\n",
+      "empresa, y períodos de los mismos. Usa formato json en la salida con las claves \"empresa\", \"puesto\"\n",
+      "y \"periodo\". Para el período, contempla cualquier formato de fecha o rango de fechas incluido en el\n",
+      "texto. Un ejemplo de formato de fecha en la entrada es \"Octubre 2023 / Marzo 2024\". El contenido\n",
+      "para la clave \"período\" debe ser un string con dos elementos en formato YYYYMM separados por un\n",
+      "guion, por ejemplo \"202310-202403\", o uno en caso de no identificarse fecha de fin.\n"
+     ]
+    }
+   ],
+   "source": [
+    "explicacion_fechas = (\n",
+    "    'Para el período, contempla cualquier formato de fecha o rango de fechas incluido en el texto. '\n",
+    "    'Un ejemplo de formato de fecha en la entrada es \"Octubre 2023 / Marzo 2024\". '\n",
+    "    'El contenido para la clave \"período\" debe ser un string con dos elementos en formato YYYYMM '\n",
+    "    'separados por un guion, por ejemplo \"202310-202403\", o uno en caso de no identificarse fecha de fin.'\n",
+    "    )\n",
+    "\n",
+    "ner_pre_prompt = (\n",
+    "  'Eres un procesador de currículos vitae que extrae títulos de puestos de trabajo, '\n",
+    "  'nombres de la empresa, y períodos de los mismos. Usa formato json en la salida '\n",
+    "  f'con las claves \"empresa\", \"puesto\" y \"periodo\". {explicacion_fechas}'\n",
+    ")\n",
+    "\n",
+    "# Guardamos el prompt para el reconocimiento de entidades nombradas en un archivo de texto\n",
+    "with open('../prompts/ner_pre_prompt.txt', 'w', encoding='utf-8') as file:\n",
+    "    file.write(ner_pre_prompt)\n",
+    "\n",
+    "wrapped_ner_pre_prompt = textwrap.fill(ner_pre_prompt, width=100)\n",
+    "print(wrapped_ner_pre_prompt)\n",
+    "cv_sample_2_path = '../../ejemplos_cvs/cv_sample_2.txt'\n",
+    "with open(cv_sample_2_path, 'r') as file:\n",
+    "    cv_text_2 = file.read()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Datos estructurados:\n",
+      " {\n",
+      "    \"records\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Autónomo\",\n",
+      "            \"puesto\": \"Comercial de automoviles\",\n",
+      "            \"periodo\": \"202401-202402\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "            \"periodo\": \"202310-202403\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"AGRISOLUTIONS\",\n",
+      "            \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "            \"periodo\": \"202001-202401\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "            \"puesto\": \"Camarero/a de barra\",\n",
+      "            \"periodo\": \"202303-202309\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"ZEREGUIN ZERBITZUAK\",\n",
+      "            \"puesto\": \"limpieza industrial\",\n",
+      "            \"periodo\": \"202012-202305\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Bellota Herramientas\",\n",
+      "            \"puesto\": \"Personal de mantenimiento\",\n",
+      "            \"periodo\": \"202005-202011\"\n",
+      "        }\n",
+      "    ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Definimos el esquema en formato JSON\n",
+    "schema = {\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {\n",
+    "        \"records\": {\n",
+    "            \"type\": \"array\",\n",
+    "            \"items\": {\n",
+    "                \"type\": \"object\",\n",
+    "                \"properties\": {\n",
+    "                    \"empresa\": {\"type\": \"string\"},\n",
+    "                    \"puesto\": {\"type\": \"string\"},\n",
+    "                    \"periodo\": {\n",
+    "                        \"type\": \"string\",\n",
+    "                        \"description\": \"Formato 'YYYYMM-YYYYMM' o simplemente 'YYYYMM' si no aparece fecha de fin.\"\n",
+    "                    }\n",
+    "                },\n",
+    "                \"required\": [\"empresa\", \"puesto\", \"periodo\"]\n",
+    "            }\n",
+    "        }\n",
+    "    },\n",
+    "    \"required\": [\"records\"]\n",
+    "}\n",
+    "\n",
+    "# Llamamos a la API, incluyendo el esquema deseado en el parámetro 'functions'\n",
+    "response = client.chat.completions.create(\n",
+    "    model=\"gpt-4o-mini\",\n",
+    "    messages=[\n",
+    "        {\"role\": \"system\", \"content\": ner_pre_prompt},\n",
+    "        {\"role\": \"user\", \"content\": cv_text}\n",
+    "    ],\n",
+    "    functions=[\n",
+    "        {\n",
+    "            \"name\": \"extraer_datos_cv\",\n",
+    "            \"description\": \"Extrae tabla con títulos de puesto de trabajo, nombres de empresa y períodos de un CV.\",\n",
+    "            \"parameters\": schema\n",
+    "        }\n",
+    "    ],\n",
+    "    function_call=\"auto\"\n",
+    ")\n",
+    "\n",
+    "# Extraemos de la respuesta sólo los datos de la función\n",
+    "if response.choices[0].message.function_call:\n",
+    "    function_call = response.choices[0].message.function_call\n",
+    "    structured_output = json.loads(function_call.arguments)\n",
+    "    print(\"Datos estructurados:\\n\", json.dumps(structured_output, indent=4, ensure_ascii=False))\n",
+    "else:\n",
+    "    print(\"No se han podido extraer datos estructurados.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. NER con esquema en fichero .JSON"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Para desarrollar el código ejecutable más adelante, vamos a utilizar un fichero .json externo con el esquema, lo que facilita el control de versiones y simplifica el código:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Datos estructurados:\n",
+      " {\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Autónomo\",\n",
+      "            \"puesto\": \"Comercial de automoviles\",\n",
+      "            \"periodo\": \"202401-202402\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "            \"periodo\": \"202310-202403\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"AGRISOLUTIONS\",\n",
+      "            \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "            \"periodo\": \"202001-202401\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "            \"puesto\": \"Camarero/a de barra\",\n",
+      "            \"periodo\": \"202303-202309\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"ZEREGUIN ZERBITZUAK\",\n",
+      "            \"puesto\": \"limpieza industrial\",\n",
+      "            \"periodo\": \"202012-202305\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Bellota Herramientas\",\n",
+      "            \"puesto\": \"Personal de mantenimiento\",\n",
+      "            \"periodo\": \"202005-202011\"\n",
+      "        }\n",
+      "    ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Cargamos el esquema:\n",
+    "with open('../json/ner_schema.json', 'r', encoding='utf-8') as schema_file:\n",
+    "    schema = json.load(schema_file)\n",
+    "\n",
+    "# Cargamos el CV:\n",
+    "cv_sample_path = '../../ejemplos_cvs/cv_sample.txt' # Ruta al fichero de texto con un currículo de ejemplo\n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "\n",
+    "def extraer_datos_cv(pre_prompt, schema, cv, temperature=0.5):\n",
+    "    response = client.chat.completions.create(\n",
+    "        model=\"gpt-4o-mini\",\n",
+    "        temperature=temperature,\n",
+    "        messages=[\n",
+    "            {\"role\": \"system\", \"content\": pre_prompt},\n",
+    "            {\"role\": \"user\", \"content\": cv}\n",
+    "        ],\n",
+    "        functions=[\n",
+    "            {\n",
+    "                \"name\": \"extraer_datos_cv\",\n",
+    "                \"description\": \"Extrae tabla con títulos de puesto de trabajo, nombres de empresa y períodos de un CV.\",\n",
+    "                \"parameters\": schema\n",
+    "            }\n",
+    "        ],\n",
+    "        function_call=\"auto\"\n",
+    "    )\n",
+    "\n",
+    "    if response.choices[0].message.function_call:\n",
+    "        function_call = response.choices[0].message.function_call\n",
+    "        structured_output = json.loads(function_call.arguments)\n",
+    "        if structured_output.get(\"experiencia\"):\n",
+    "            return structured_output\n",
+    "        else:\n",
+    "            return {\"error\": f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\"}\n",
+    "    else:\n",
+    "        return {\"error\": f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\"}\n",
+    "    \n",
+    "datos_estructurados_cv = extraer_datos_cv(ner_pre_prompt, schema, cv_text)\n",
+    "print(\"Datos estructurados:\\n\", json.dumps(datos_estructurados_cv, indent=4, ensure_ascii=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Pruebas adicionales"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "En las siguientes pruebas, experimentamos con modificaciones del parámetro de temperatura en casos extremos de textos atípicos. El objetivo principal es asegurar que el agente extraiga toda la información válida posible pero, a la vez, evite \"alucinar\" cuando reciba datos confusos. Un parámetro muy alto de temperatura puede producir algunas alucinaciones en casos muy excepcionales, por lo que usaremos un parámetro muy \"conservador\". En cualquier caso, las pruebas son suficientes para estar muy \"cómodos\" con la efectividad del modelo gpt-4o-mini en esta tarea: tiene un rendimiento muy sólido."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Currículum \"minimalista\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Datos estructurados:\n",
+      " {\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor\",\n",
+      "            \"periodo\": \"\"\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Bar de tapas\",\n",
+      "            \"puesto\": \"Camarero\",\n",
+      "            \"periodo\": \"\"\n",
+      "        }\n",
+      "    ]\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "cv_text_mini = \"Soy un vendedor de puesto de mercado en Mercadona. Antes trabajé como camarero en un bar de tapas.\"\n",
+    "datos_estructurados_cv_mini = extraer_datos_cv(ner_pre_prompt, schema, cv_text_mini, temperature=0.1)\n",
+    "print(\"Datos estructurados:\\n\", json.dumps(datos_estructurados_cv_mini, indent=4, ensure_ascii=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Texto inválido:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Datos estructurados:\n",
+      " {\n",
+      "    \"error\": \"No se han podido extraer datos estructurados: None\"\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "cv_text_hal = (\n",
+    "    \"El rápido zorro marrón salta sobre el perezoso perro. El perro ladra al zorro. \"\n",
+    "    \"Los dos animales se miran fijamente. Es una escena común en el bosque. Me gusta el bosque.\"\n",
+    ")\n",
+    "\n",
+    "datos_estructurados_cv_hal = extraer_datos_cv(ner_pre_prompt, schema, cv_text_hal, temperature=0.1)\n",
+    "print(\"Datos estructurados:\\n\", json.dumps(datos_estructurados_cv_hal, indent=4, ensure_ascii=False))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Datos estructurados:\n",
+      " {\n",
+      "    \"error\": \"No se han podido extraer datos estructurados: None\"\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "cv_text_hal = (\n",
+    "    \"El rápido zorro marrón salta sobre el perezoso perro. El perro ladra al zorro. \"\n",
+    "    \"Los dos animales se miran fijamente. Es una escena común en el bosque. Me gusta el bosque.\"\n",
+    ")\n",
+    "\n",
+    "datos_estructurados_cv_hal = extraer_datos_cv(ner_pre_prompt, schema, cv_text_hal, temperature=2)\n",
+    "print(\"Datos estructurados:\\n\", json.dumps(datos_estructurados_cv_hal, indent=4, ensure_ascii=False))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/02-puntuacion-de-cv-con-embeddings.ipynb

@@ -0,0 +1,1483 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key: sk-proj-****************************************************************************************************************************************************-amA_5sA\n",
+      "Cliente inicializado como <openai.OpenAI object at 0x0000021664BC5ED0>\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "from scipy import spatial\n",
+    "from openai import OpenAI\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv(\"../../../../../../../apis/.env\")\n",
+    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "unmasked_chars = 8\n",
+    "masked_key = api_key[:unmasked_chars] + '*' * (len(api_key) - unmasked_chars*2) + api_key[-unmasked_chars:]\n",
+    "print(f\"API key: {masked_key}\")\n",
+    "client = OpenAI(api_key=api_key)\n",
+    "print(\"Cliente inicializado como\",client)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Ejemplos básicos de cálculo de distancia con embeddings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-07</td>\n",
+       "      <td>11</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  \n",
+       "0         202401  2024-01-01  2024-12-07        11  \n",
+       "1  202310-202404  2023-10-01  2024-04-01         6  \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48  \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6  \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29  \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Vendedor/a de puesto de mercado\n"
+     ]
+    }
+   ],
+   "source": [
+    "ejemplos_experiencia = pd.read_pickle(\"../pkl/df_experiencia.pkl\")\n",
+    "display(ejemplos_experiencia)\n",
+    "print(ejemplos_experiencia.puesto[1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Texto: Vendedor/a de puesto de mercado\n",
+      "Embeddings (1536): [-0.006109286565333605, -0.01615688018500805, 0.02458987757563591, 0.0013343609170988202, -0.04200134426355362, 0.015196849592030048, 0.010587611235678196, 0.03497566282749176, -0.015262306667864323, -0.031200997531414032]...\n"
+     ]
+    }
+   ],
+   "source": [
+    "client = OpenAI()\n",
+    "puesto_vendedor = ejemplos_experiencia.puesto[1]\n",
+    "\n",
+    "response = client.embeddings.create(\n",
+    "    input=puesto_vendedor,\n",
+    "    model=\"text-embedding-3-small\"\n",
+    ")\n",
+    "emb_puesto_vendedor = response.data[0].embedding\n",
+    "print(f'Texto: {puesto_vendedor}\\nEmbeddings ({len(emb_puesto_vendedor)}): {emb_puesto_vendedor[:10]}...')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Texto: Camarero/a de barra\n",
+      "Embeddings (1536): [-0.035160087049007416, -0.0017518880777060986, -0.006896876264363527, -0.040239546447992325, -0.024628372862935066, 0.000213889084989205, 4.456970600585919e-06, 0.047462623566389084, -0.02062072791159153, -0.03217765688896179]...\n"
+     ]
+    }
+   ],
+   "source": [
+    "puesto_camarero = ejemplos_experiencia.puesto[3]\n",
+    "\n",
+    "response = client.embeddings.create(\n",
+    "    input=puesto_camarero,\n",
+    "    model=\"text-embedding-3-small\"\n",
+    ")\n",
+    "emb_puesto_camarero = response.data[0].embedding\n",
+    "print(f'Texto: {puesto_camarero}\\nEmbeddings ({len(emb_puesto_camarero)}): {emb_puesto_camarero[:10]}...')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Texto: Cajero supermercado Dia\n",
+      "Embeddings (1536): [-0.0045319367200136185, -0.04426201060414314, -0.0222327820956707, -0.015300587750971317, 0.008034787140786648, 0.011099428869783878, 0.03736374154686928, 0.07590357959270477, -0.020332932472229004, -0.03946714848279953]...\n"
+     ]
+    }
+   ],
+   "source": [
+    "oferta_cajero = \"Cajero supermercado Dia\"\n",
+    "\n",
+    "response = client.embeddings.create(\n",
+    "    input=oferta_cajero,\n",
+    "    model=\"text-embedding-3-small\"\n",
+    ")\n",
+    "emb_oferta_cajero = response.data[0].embedding\n",
+    "print(f'Texto: {oferta_cajero}\\nEmbeddings ({len(emb_oferta_cajero)}): {emb_oferta_cajero[:10]}...')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Distancia mínima: 0.000\n",
+      "Distancia entre el puesto de vendedor y la oferta de cajero: 0.557\n",
+      "Distancia entre el puesto de camarero y la oferta de cajero: 0.587\n"
+     ]
+    }
+   ],
+   "source": [
+    "dist_min = spatial.distance.cosine(emb_oferta_cajero, emb_oferta_cajero)\n",
+    "print(f\"Distancia mínima: {dist_min:.3f}\")\n",
+    "dist_ven = spatial.distance.cosine(emb_puesto_vendedor, emb_oferta_cajero)\n",
+    "print(f\"Distancia entre el puesto de vendedor y la oferta de cajero: {dist_ven:.3f}\")\n",
+    "dist_cam = spatial.distance.cosine(emb_puesto_camarero, emb_oferta_cajero)\n",
+    "print(f\"Distancia entre el puesto de camarero y la oferta de cajero: {dist_cam:.3f}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Análisis de cálculo de distancias para el CV completo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>embeddings</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-07</td>\n",
+       "      <td>11</td>\n",
+       "      <td>[0.015070287510752678, 0.0029741383623331785, ...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>[-0.006109286565333605, -0.01615688018500805, ...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "      <td>[0.00385109125636518, 0.04469580203294754, 0.0...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>[-0.035160087049007416, -0.0017518880777060986...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "      <td>[0.003700299421325326, 0.0045193759724497795, ...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>[0.04391268640756607, 0.05462520197033882, 0.0...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  \\\n",
+       "0         202401  2024-01-01  2024-12-07        11   \n",
+       "1  202310-202404  2023-10-01  2024-04-01         6   \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48   \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6   \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29   \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6   \n",
+       "\n",
+       "                                          embeddings  \n",
+       "0  [0.015070287510752678, 0.0029741383623331785, ...  \n",
+       "1  [-0.006109286565333605, -0.01615688018500805, ...  \n",
+       "2  [0.00385109125636518, 0.04469580203294754, 0.0...  \n",
+       "3  [-0.035160087049007416, -0.0017518880777060986...  \n",
+       "4  [0.003700299421325326, 0.0045193759724497795, ...  \n",
+       "5  [0.04391268640756607, 0.05462520197033882, 0.0...  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ejemplos_experiencia['embeddings'] = ejemplos_experiencia['puesto'].apply(lambda puesto: client.embeddings.create(input=puesto, model=\"text-embedding-3-small\").data[0].embedding)\n",
+    "display(ejemplos_experiencia)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Calculamos la distancia entre la oferta \"Cajero supermercado Dia\" y cada uno de los puestos. Podemos observar que el modelo de embeddings de OpenAI es razonablemente bueno encontrando las relaciones semánticas entre textos como los del ejemplo. La experiencia que claramente tiene más relación es la que obtiene una distancia más baja. Para valorar la adecuación de los currículos a una oferta dada podríamos, obviamente, usar más datos tanto del CV como de la oferta, pero este ejemplo a pequeña escala demuestra la utilidad de los embeddings para discriminar puestos de trabajo relacionados entre sí:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia_oferta_cajero</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.556915</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.587302</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "      <td>0.617411</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-07</td>\n",
+       "      <td>11</td>\n",
+       "      <td>0.628034</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.647794</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "      <td>0.701754</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  distancia_oferta_cajero  \n",
+       "1  202310-202404  2023-10-01  2024-04-01         6                 0.556915  \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6                 0.587302  \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48                 0.617411  \n",
+       "0         202401  2024-01-01  2024-12-07        11                 0.628034  \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6                 0.647794  \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29                 0.701754  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "oferta_cajero = \"Cajero supermercado Dia\"\n",
+    "response = client.embeddings.create(\n",
+    "    input=oferta_cajero,\n",
+    "    model=\"text-embedding-3-small\"\n",
+    ")\n",
+    "emb_oferta_cajero = response.data[0].embedding\n",
+    "\n",
+    "ejemplos_experiencia['distancia_oferta_cajero'] = ejemplos_experiencia['embeddings'].apply(lambda emb: spatial.distance.cosine(emb, emb_oferta_cajero))\n",
+    "ejemplos_experiencia.drop(columns=['embeddings'], inplace=True)\n",
+    "ejemplos_experiencia_sorted = ejemplos_experiencia.sort_values(by='distancia_oferta_cajero', ascending=True).copy()\n",
+    "display(ejemplos_experiencia_sorted)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Guardamos el pickle para continuar usando este ejemplo en el siguiente bloque:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ejemplos_experiencia_sorted.to_pickle(\"../pkl/df_ejemplos_con_distancia.pkl\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Algoritmo de cálculo de puntuación"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Experimentando con múltiples ficheros de datos, podríamos llegar a refinar una fórmula de cálculo de \"puntuación\" que se adapte a nuestro caso de uso, en función de las distancias simples calculadas con embeddings y los datos de cada experiencia (tiempo de permanencia en el puesto, antigüedad de la experiencia, etc.). Con suficientes datos, podríamos incluso entrenar nuestra propia red neuronal con embeddings para determinar la predictibilidad de un cierto cambio de puesto. Por ejemplo, parece relativamente asequible, con suficientes datos de currículos incluyendo fechas, conseguir \"predecir\" que un CV cuyas últimas dos experiencias sean \"Vendedor de Planta\" y \"Analista de Pricing\" sea más apropiado para un puesto con título \"Jefe de Compras\", que un CV con última experiencia \"Jefe de Compras\" a un puesto con título \"Vendedor de Planta\". Ese tipo de relaciones semánticas y causales específicas a una industria o a un ámbito muy específico es muy difícil de obtener con un modelo de lenguaje preentrenado, pero a día de hoy tenemos las herramientas que nos facilitan \"refinar\" (finetuning) cualquiera de esos grandes modelos sin un coste muy elevado, utilizando los datos que se adapten a nuestro específico caso de uso. \n",
+    "\n",
+    "<br>Para esta prueba de concepto, no disponemos de una amplia base de datos de currículos, por lo que definiremos un **sistema de puntuación simplificado basado exclusivamente en las distancias de embeddings, en la cantidad de experiencias previas y en la duración de las mismas**. No tendremos en cuenta factores muy importantes como la inferencia de causalidad y secuencialidad, así como detalles de los currículos y de la oferta de trabajo más allá de los títulos. \n",
+    "\n",
+    "<br>En cualquier caso, debe tenerse en cuenta que un sistema de análisis algorítmico sobre datos de CVs ha de usarse con suma cautela, debido al alto riesgo de obtener \"falsos negativos\" (https://es.wikipedia.org/wiki/Falso_positivo_y_falso_negativo): descartar un candidato potencialmente bueno, sin llegar a ver más datos que los de un fichero de texto. En este caso de uso, el riesgo de \"falso positivo\" (no descartar a un candidato no apropiado), no es tan crítico, dado que la revisión de datos de CVs es sólo una fase muy preliminar de un proceso de selección. En otras palabras, **el impacto en el negocio del \"falso positivo\" es hacer una entrevista de más, mientras que el impacto de un \"falso negativo\" es perder un buen candidato.**\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.556915</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.587302</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "      <td>0.617411</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-07</td>\n",
+       "      <td>11</td>\n",
+       "      <td>0.628034</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.647790</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "      <td>0.701754</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  distancia  \n",
+       "1  202310-202404  2023-10-01  2024-04-01         6   0.556915  \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6   0.587302  \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48   0.617411  \n",
+       "0         202401  2024-01-01  2024-12-07        11   0.628034  \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6   0.647790  \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29   0.701754  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ejemplos_experiencia_sorted = pd.read_pickle(\"../pkl/df_ejemplos_con_distancia.pkl\")\n",
+    "ejemplos_experiencia_sorted.rename(columns={'distancia_oferta_cajero':'distancia'}, inplace=True)\n",
+    "display(ejemplos_experiencia_sorted)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Algoritmo de puntuación:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calcula_puntuacion(df, req_experience, positions_cap=4, min_dist_threshold=0.6, max_dist_threshold=0.7):\n",
+    "    \"\"\"\n",
+    "    Calcula la puntuación de un CV a partir de su tabla de distancias (con respecto a un puesto dado) y duraciones. \n",
+    "\n",
+    "    Params:\n",
+    "    df (pandas.DataFrame): datos de un CV incluyendo diferentes experiencias incluyendo duracies y distancia previamente calculadas sobre los embeddings de un puesto de trabajo\n",
+    "    req_experience (float): experiencia requerida en meses para el puesto de trabajo (valor de referencia para calcular una puntuación entre 0 y 100 en base a diferentes experiencias)\n",
+    "    positions_cap (int, optional): Maximum number of positions to consider for scoring. Defaults to 4.\n",
+    "    min_dist_threshold (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV se considera \"equivalente\" al de la oferta.\n",
+    "    max_dist_threshold (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV no puntúa.\n",
+    "    \n",
+    "    Returns:\n",
+    "    pandas.DataFrame: DataFrame original añadiendo una columna con las puntuaciones individuales contribuidas por cada puesto.\n",
+    "    float: Puntuación total entre 0 y 100.\n",
+    "    \"\"\"\n",
+    "    # A efectos de puntuación, computamos para cada puesto como máximo el número total de meses de experiencia requeridos\n",
+    "    df['duration_capped'] = df['duracion'].apply(lambda x: min(x, req_experience))\n",
+    "    # Normalizamos la distancia entre 0 y 1, siendo 0 la distancia mínima y 1 la máxima\n",
+    "    df['adjusted_distance'] = df['distancia'].apply(\n",
+    "        lambda x: 0 if x <= min_dist_threshold else (\n",
+    "            1 if x >= max_dist_threshold else (x - min_dist_threshold) / (max_dist_threshold - min_dist_threshold)\n",
+    "        )\n",
+    "    )\n",
+    "    # Cada puesto puntúa en base a su duración y a la inversa de la distancia (a menor distancia, mayor puntuación)\n",
+    "    df['position_score'] = ((1 - df['adjusted_distance']) * (df['duration_capped']/req_experience) * 100)\n",
+    "    # Descartamos puestos con distancia superior al umbral definido (asignamos puntuación 0), y ordenamos por puntuación\n",
+    "    df.loc[df['distancia'] >= max_dist_threshold, 'position_score'] = 0\n",
+    "    df = df.sort_values(by='position_score', ascending=False)\n",
+    "    # Nos quedamos con los positions_cap puestos con mayor puntuación\n",
+    "    df.iloc[positions_cap:, df.columns.get_loc('position_score')] = 0\n",
+    "    # Totalizamos (no debería superar 100 nunca, pero ponemos un límite para asegurar)\n",
+    "    total_score = min(df['position_score'].sum(), 100)\n",
+    "    return df, total_score"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Para entender mejor el algoritmo, podemos probar el currículo de ejemplo para el que habíamos calculado las distancias con el puesto \"Cajero supermercado Dia\". En su experiencia anterior, veíamos que el puesto más cercano es el de \"Vendedor/a de puesto de mercado\", pero sólo tiene 6 meses de experiencia. Si probáramos con una experiencia requerida muy alta, como 48 meses, este CV daría una puntuación muy baja. Si, en cambio, el requisito de experiencia es más bajo, el CV obtendrá una puntuación alta gracias a este puesto. Además, los puestos que tienen menor relación semántica con la oferta, pero más meses de experiencia, puntuarán más en función del ajuste de los parámetros de umbral mínimo y máximo de distancia. \n",
+    "\n",
+    "<br>El ajuste fino de los parámetros de umbral mínimo y máximo de distancia de embeddings hace que las experiencias con título más diferente al de la oferta tengan más o menos peso en la puntuación. Estos no son parámetros intuitivos y sólo se pueden ajustar en base a la experiencia: en la aplicación de usuario final, se etiquetarán como \"parámetros avanzados\" y la recomendación sería encontrar unos valores por defecto \"óptimos\" en función de la experiencia de múltiples casos de uso. Para este ejemplo, hemos elegido 0.55 y 0.63, dado que sirven para ilustrar muy bien el siguiente ejemplo, si probamos diferentes valores para req_experience (el parámetro positions_cap podemos dejarlo en 4 y no impacta mucho en la puntuación). Estos parámetros se pueden ajustar en función del título de la oferta, quedando fijos para comparar diferentes currículos. **El rango óptimo para los parámetros min_dist_threshold y max_dist_threshold depende funcamentalmente de la longitud del texto de la oferta de trabajo a introducir**. En un entorno real, en el que se evalúen diferentes ofertas, se podrían determinar unos valores \"recomendados\" de umbrales, pero para este sencillo ejercicio, lógicamente, no disponemos de datos suficientes para realizar ese ajuste fino. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Puntuación: 90.4/100\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202404</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-04-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.556915</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.086437</td>\n",
+       "      <td>45.678127</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.587302</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.466269</td>\n",
+       "      <td>26.686531</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "      <td>0.617411</td>\n",
+       "      <td>12</td>\n",
+       "      <td>0.842632</td>\n",
+       "      <td>15.736790</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-12-07</td>\n",
+       "      <td>11</td>\n",
+       "      <td>0.628034</td>\n",
+       "      <td>11</td>\n",
+       "      <td>0.975419</td>\n",
+       "      <td>2.253279</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.647790</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "      <td>0.701754</td>\n",
+       "      <td>12</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  distancia  \\\n",
+       "1  202310-202404  2023-10-01  2024-04-01         6   0.556915   \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6   0.587302   \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48   0.617411   \n",
+       "0         202401  2024-01-01  2024-12-07        11   0.628034   \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6   0.647790   \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29   0.701754   \n",
+       "\n",
+       "   duration_capped  adjusted_distance  position_score  \n",
+       "1                6           0.086437       45.678127  \n",
+       "3                6           0.466269       26.686531  \n",
+       "2               12           0.842632       15.736790  \n",
+       "0               11           0.975419        2.253279  \n",
+       "5                6           1.000000        0.000000  \n",
+       "4               12           1.000000        0.000000  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Ejemplo de uso con el currículo del notebook anterior\n",
+    "args = [12, 4, 0.55, 0.63] # Argumentos req_experience, positions_cap, min_distance, max_distance\n",
+    "scored_df, total_score = calcula_puntuacion(ejemplos_experiencia_sorted, *args)\n",
+    "print(f\"Puntuación: {total_score:.1f}/100\")\n",
+    "display(scored_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Ejemplos de puntuación:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Para entender mejor el sistema de puntuación, podemos evaluar diferentes ejemplos en los que el requisito de experiencia sea 100 meses y establezcamos un límite de 4 posiciones a considerar. Los límites de distancia de embeddings no son relevantes en este caso, aunque los elegimos en función de los experimentos realizados anteriormente. Utilizamos los umbrales 0.6 y 0.7 para ilustrar un posible rango razonable de distancias de embeddings para una descripción corta como la utilizada. **El rango óptimo para estos parámetros depende funcamentalmente de la longitud del texto de la oferta de trabajo a introducir**."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "args = [100, 4, 0.6, 0.7] # req_experience, positions_cap, min_distance, max_distance"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4 experiencias en puesto muy similar al ofertado, sumando 99 meses:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total Score: 99.00\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.6</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.6</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.6</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>24</td>\n",
+       "      <td>0.6</td>\n",
+       "      <td>24</td>\n",
+       "      <td>0</td>\n",
+       "      <td>24.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>23</td>\n",
+       "      <td>0.6</td>\n",
+       "      <td>23</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   duracion  distancia  duration_capped  adjusted_distance  position_score\n",
+       "0        25        0.6               25                  0            25.0\n",
+       "1        25        0.6               25                  0            25.0\n",
+       "2        25        0.6               25                  0            25.0\n",
+       "3        24        0.6               24                  0            24.0\n",
+       "4        23        0.6               23                  0             0.0"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = [\n",
+    "    {'duracion': 25, 'distancia': 0.6},\n",
+    "    {'duracion': 25, 'distancia': 0.6},\n",
+    "    {'duracion': 25, 'distancia': 0.6},\n",
+    "    {'duracion': 24, 'distancia': 0.6},\n",
+    "    {'duracion': 23, 'distancia': 0.6} # Esta última posición no cuenta, al poner un límite de 4 y ser la de menor puntuación\n",
+    "]\n",
+    "\n",
+    "df_very_high_score = pd.DataFrame(data)\n",
+    "scored_df, total_score = calcula_puntuacion(df_very_high_score, *args)\n",
+    "print(f\"Total Score: {total_score:.2f}\")\n",
+    "display(scored_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "4 experiencias en puestos menos similares al ofertado, sumando 100 meses:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total Score: 90.00\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>22.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>22.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>22.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.61</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0.1</td>\n",
+       "      <td>22.5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>25</td>\n",
+       "      <td>0.2</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   duracion  distancia  duration_capped  adjusted_distance  position_score\n",
+       "0        25       0.61               25                0.1            22.5\n",
+       "1        25       0.61               25                0.1            22.5\n",
+       "2        25       0.61               25                0.1            22.5\n",
+       "3        25       0.61               25                0.1            22.5\n",
+       "4        25       0.62               25                0.2             0.0"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = [\n",
+    "    {'duracion': 25, 'distancia': 0.61},\n",
+    "    {'duracion': 25, 'distancia': 0.61},\n",
+    "    {'duracion': 25, 'distancia': 0.61},\n",
+    "    {'duracion': 25, 'distancia': 0.61},\n",
+    "    {'duracion': 25, 'distancia': 0.62} # Esta última posición no cuenta, al poner un límite de 4 y ser la de menor puntuación\n",
+    "]\n",
+    "\n",
+    "df_high_score = pd.DataFrame(data)\n",
+    "scored_df, total_score = calcula_puntuacion(df_high_score, *args)\n",
+    "print(f\"Total Score: {total_score:.2f}\")\n",
+    "display(scored_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Una experiencia de 100 meses en un puesto de \"distancia intermedia\" al ofertado:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total Score: 50.00\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>100</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>100</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>50.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>23</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>23</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   duracion  distancia  duration_capped  adjusted_distance  position_score\n",
+       "0       100       0.65              100                0.5            50.0\n",
+       "1        25       0.70               25                1.0             0.0\n",
+       "2        25       0.70               25                1.0             0.0\n",
+       "3        25       0.70               25                1.0             0.0\n",
+       "4        23       0.70               23                1.0             0.0"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = [\n",
+    "    {'duracion': 100, 'distancia': 0.65},\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "    {'duracion': 23, 'distancia': 0.7} # Descartado por distancia\n",
+    "]\n",
+    "\n",
+    "df_mid_score = pd.DataFrame(data)\n",
+    "scored_df, total_score = calcula_puntuacion(df_mid_score, *args)\n",
+    "print(f\"Total Score: {total_score:.2f}\")\n",
+    "display(scored_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "50 meses en un puesto muy similar y 50 meses en un puesto de \"distancia intermedia\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Total Score: 75.00\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>50</td>\n",
+       "      <td>0.60</td>\n",
+       "      <td>50</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>50.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>50</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>50</td>\n",
+       "      <td>0.5</td>\n",
+       "      <td>25.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>25</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>25</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   duracion  distancia  duration_capped  adjusted_distance  position_score\n",
+       "0        50       0.60               50                0.0            50.0\n",
+       "1        50       0.65               50                0.5            25.0\n",
+       "2        25       0.70               25                1.0             0.0\n",
+       "3        25       0.70               25                1.0             0.0\n",
+       "4        25       0.70               25                1.0             0.0"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "data = [\n",
+    "    {'duracion': 50, 'distancia': 0.6},\n",
+    "    {'duracion': 50, 'distancia': 0.65},\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "    {'duracion': 25, 'distancia': 0.7}, # Descartado por distancia\n",
+    "]\n",
+    "\n",
+    "df_mid_high_score = pd.DataFrame(data)\n",
+    "scored_df, total_score = calcula_puntuacion(df_mid_high_score, *args)\n",
+    "print(f\"Total Score: {total_score:.2f}\")\n",
+    "display(scored_df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Llamada al modelo para generar el fichero JSON final de salida"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "El último paso, una vez extraídos los datos y calculadas las puntuaciones, será llamar al modelo para que genere un fichero JSON de salida con la siguiente información:\n",
+    "\n",
+    "- Puntuación total.\n",
+    "- Listado de experiencias relevantes.\n",
+    "- Descripción de la experiencia.\n",
+    "\n",
+    "Los dos primeros elementos se calculan mediante la inferencia de reconocimiento de entidades nombradas del notebook 01, y los cálculos con embeddings de este notebook. Para obetener la salida estructurada completa, haremos una nueva llamada a un modelo gpt en la que le pasaremos la puntuación y la tabla de datos completa, para que elabore un texto explicativo y coherente con los datos calculados. En el siguiente notebook, ejecutaremos el proceso completo para el CV de ejemplo con el que hemos estado trabajando."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/03-poc-completa-en-notebook.ipynb

@@ -0,0 +1,1245 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 0. Preparación del notebook"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key: sk-proj-****************************************************************************************************************************************************-amA_5sA\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import json\n",
+    "import textwrap\n",
+    "from scipy import spatial\n",
+    "from datetime import datetime\n",
+    "from openai import OpenAI\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "from IPython.display import display # Sólo para la ejecución en Jupyter\n",
+    "\n",
+    "load_dotenv(\"../../../../../../../apis/.env\")\n",
+    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "unmasked_chars = 8\n",
+    "masked_key = api_key[:unmasked_chars] + '*' * (len(api_key) - unmasked_chars*2) + api_key[-unmasked_chars:]\n",
+    "print(f\"API key: {masked_key}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Funciones de procesamiento de datos y cálculo de puntuación"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ProcesadorCV:\n",
+    "\n",
+    "    def __init__(self, api_key, cv_text, job_text, ner_pre_prompt, ner_schema,\n",
+    "                inference_model=\"gpt-4o-mini\", embeddings_model=\"text-embedding-3-small\"):\n",
+    "        \"\"\"\n",
+    "        Inicializa una instancia de la clase con los parámetros proporcionados.\n",
+    "\n",
+    "        Args:\n",
+    "            api_key (str): La clave de API para autenticar con el cliente OpenAI.\n",
+    "            cv_text (str): contenido del CV en formato de texto.\n",
+    "            job_text (str): título de la oferta de trabajo a evaluar.\n",
+    "            ner_pre_prompt (str): instrucción de \"reconocimiento de entidades nombradas\" (NER) para el modelo en lenguaje natural.\n",
+    "            ner_schema (dict): esquema para la llamada con \"structured outputs\" al modelo de OpenAI.\n",
+    "            inference_model (str, opcional): El modelo de inferencia a utilizar. Por defecto es \"gpt-4o-mini\".\n",
+    "            embeddings_model (str, opcional): El modelo de embeddings a utilizar. Por defecto es \"text-embedding-3-small\".\n",
+    "\n",
+    "        Atributos:\n",
+    "            inference_model (str): Almacena el modelo de inferencia seleccionado.\n",
+    "            embeddings_model (str): Almacena el modelo de embeddings seleccionado.\n",
+    "            client (OpenAI): Instancia del cliente OpenAI inicializada con la clave de API proporcionada.\n",
+    "            cv (str): Almacena el texto del currículum vitae proporcionado.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        self.inference_model = inference_model\n",
+    "        self.embeddings_model = embeddings_model\n",
+    "        self.ner_pre_prompt = ner_pre_prompt\n",
+    "        self.ner_schema = ner_schema\n",
+    "        self.client = OpenAI(api_key=api_key)\n",
+    "        self.cv = cv_text\n",
+    "        self.job_text = job_text\n",
+    "        print(\"Cliente inicializado como\",self.client)\n",
+    "\n",
+    "    def extraer_datos_cv(self, temperature=0.5):\n",
+    "        \"\"\"\n",
+    "        Extrae datos estructurados de un CV con OpenAI API.\n",
+    "        Args:\n",
+    "            pre_prompt (str): instrucción para el modelo en lenguaje natural.\n",
+    "            schema (dict): esquema de los parámetros que se espera extraer del CV.\n",
+    "            temperature (float, optional): valor de temperatura para el modelo de lenguaje. Por defecto es 0.5.\n",
+    "        Returns:\n",
+    "            pd.DataFrame: DataFrame con los datos estructurados extraídos del CV.\n",
+    "        Raises:\n",
+    "            ValueError: si no se pueden extraer datos estructurados del CV.\n",
+    "        \"\"\"\n",
+    "        response = self.client.chat.completions.create(\n",
+    "            model=self.inference_model,\n",
+    "            temperature=temperature,\n",
+    "            messages=[\n",
+    "                {\"role\": \"system\", \"content\": self.ner_pre_prompt},\n",
+    "                {\"role\": \"user\", \"content\": self.cv}\n",
+    "            ],\n",
+    "            functions=[\n",
+    "                {\n",
+    "                    \"name\": \"extraer_datos_cv\",\n",
+    "                    \"description\": \"Extrae tabla con títulos de puesto de trabajo, nombres de empresa y períodos de un CV.\",\n",
+    "                    \"parameters\": self.ner_schema\n",
+    "                }\n",
+    "            ],\n",
+    "            function_call=\"auto\"\n",
+    "        )\n",
+    "\n",
+    "        if response.choices[0].message.function_call:\n",
+    "            function_call = response.choices[0].message.function_call\n",
+    "            structured_output = json.loads(function_call.arguments)\n",
+    "            if structured_output.get(\"experiencia\"):\n",
+    "                df_cv = pd.DataFrame(structured_output[\"experiencia\"]) \n",
+    "                return df_cv\n",
+    "            else:\n",
+    "                raise ValueError(f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\")\n",
+    "        else:\n",
+    "            raise ValueError(f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\")\n",
+    "        \n",
+    "\n",
+    "    def procesar_periodos(self, df):    \n",
+    "        \"\"\"\n",
+    "        Procesa los períodos en un DataFrame y añade columnas con las fechas de inicio, fin y duración en meses. \n",
+    "        Si no hay fecha de fin, se considera la fecha actual.\n",
+    "        Args:\n",
+    "            df (pandas.DataFrame): DataFrame que contiene una columna 'periodo' con períodos en formato 'YYYYMM-YYYYMM' o 'YYYYMM'.\n",
+    "        Returns:\n",
+    "            pandas.DataFrame: DataFrame con columnas adicionales 'fec_inicio', 'fec_final' y 'duracion'.\n",
+    "                - 'fec_inicio' (datetime.date): Fecha de inicio del período.\n",
+    "                - 'fec_final' (datetime.date): Fecha de fin del período.\n",
+    "                - 'duracion' (int): Duración del período en meses.\n",
+    "        \"\"\"\n",
+    "        # Función lambda para procesar el período\n",
+    "        def split_periodo(periodo):\n",
+    "            dates = periodo.split('-')\n",
+    "            start_date = datetime.strptime(dates[0], \"%Y%m\")\n",
+    "            if len(dates) > 1:\n",
+    "                end_date = datetime.strptime(dates[1], \"%Y%m\")\n",
+    "            else:\n",
+    "                end_date = datetime.now()\n",
+    "            return start_date, end_date\n",
+    "\n",
+    "        df[['fec_inicio', 'fec_final']] = df['periodo'].apply(lambda x: pd.Series(split_periodo(x)))\n",
+    "\n",
+    "        # Formateamos las fechas para mostrar mes, año, y el primer día del mes (dado que el día es irrelevante y no se suele especificar)\n",
+    "        df['fec_inicio'] = df['fec_inicio'].dt.date\n",
+    "        df['fec_final'] = df['fec_final'].dt.date\n",
+    "\n",
+    "        # Añadimos una columna con la duración en meses\n",
+    "        df['duracion'] = df.apply(\n",
+    "            lambda row: (row['fec_final'].year - row['fec_inicio'].year) * 12 + \n",
+    "                        row['fec_final'].month - row['fec_inicio'].month, \n",
+    "            axis=1\n",
+    "        )\n",
+    "\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_embeddings(self, df, column='puesto', model_name='text-embedding-3-small'):\n",
+    "        \"\"\"\n",
+    "        Calcula los embeddings de una columna de un dataframe con OpenAI API.\n",
+    "        Args:\n",
+    "            cv_df (pandas.DataFrame): DataFrame con los datos de los CV.\n",
+    "            column (str, optional): Nombre de la columna que contiene los datos a convertir en embeddings. Por defecto es 'puesto'.\n",
+    "            model_name (str, optional): Nombre del modelo de embeddings. Por defecto es 'text-embedding-3-small'.\n",
+    "        \"\"\"\n",
+    "        df['embeddings'] = df[column].apply(\n",
+    "            lambda puesto: self.client.embeddings.create(\n",
+    "                input=puesto, \n",
+    "                model=model_name\n",
+    "            ).data[0].embedding\n",
+    "        )\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_distancias(self, df, column='embeddings', model_name='text-embedding-3-small'):\n",
+    "        \"\"\"\n",
+    "        Calcula la distancia coseno entre los embeddings del texto y los incluidos en una columna del dataframe.\n",
+    "        Params:\n",
+    "        df (pandas.DataFrame): DataFrame que contiene los embeddings.\n",
+    "        column (str, optional): nombre de la columna del DataFrame que contiene los embeddings. Por defecto, 'embeddings'.\n",
+    "        model_name (str, optional): modelo de embeddings de la API de OpenAI. Por defecto \"text-embedding-3-small\".\n",
+    "        Returns:\n",
+    "        pandas.DataFrame: DataFrame ordenado de menor a mayor distancia, con las distancias en una nueva columna.\n",
+    "        \"\"\"\n",
+    "        response = self.client.embeddings.create(\n",
+    "            input=self.job_text,\n",
+    "            model=model_name\n",
+    "        )\n",
+    "        emb_compare = response.data[0].embedding\n",
+    "\n",
+    "        df['distancia'] = df[column].apply(lambda emb: spatial.distance.cosine(emb, emb_compare))\n",
+    "        df.drop(columns=[column], inplace=True)\n",
+    "        df.sort_values(by='distancia', ascending=True, inplace=True)\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_puntuacion(self, df, req_experience, positions_cap=4, dist_threshold_low=0.6, dist_threshold_high=0.7):\n",
+    "        \"\"\"\n",
+    "        Calcula la puntuación de un CV a partir de su tabla de distancias (con respecto a un puesto dado) y duraciones. \n",
+    "\n",
+    "        Params:\n",
+    "        df (pandas.DataFrame): datos de un CV incluyendo diferentes experiencias incluyendo duracies y distancia previamente calculadas sobre los embeddings de un puesto de trabajo\n",
+    "        req_experience (float): experiencia requerida en meses para el puesto de trabajo (valor de referencia para calcular una puntuación entre 0 y 100 en base a diferentes experiencias)\n",
+    "        positions_cap (int, optional): Maximum number of positions to consider for scoring. Defaults to 4.\n",
+    "        dist_threshold_low (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV se considera \"equivalente\" al de la oferta.\n",
+    "        max_dist_threshold (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV no puntúa.\n",
+    "        \n",
+    "        Returns:\n",
+    "        pandas.DataFrame: DataFrame original añadiendo una columna con las puntuaciones individuales contribuidas por cada puesto.\n",
+    "        float: Puntuación total entre 0 y 100.\n",
+    "        \"\"\"\n",
+    "        # A efectos de puntuación, computamos para cada puesto como máximo el número total de meses de experiencia requeridos\n",
+    "        df['duration_capped'] = df['duracion'].apply(lambda x: min(x, req_experience))\n",
+    "        # Normalizamos la distancia entre 0 y 1, siendo 0 la distancia mínima y 1 la máxima\n",
+    "        df['adjusted_distance'] = df['distancia'].apply(\n",
+    "            lambda x: 0 if x <= dist_threshold_low else (\n",
+    "                1 if x >= dist_threshold_high else (x - dist_threshold_low) / (dist_threshold_high - dist_threshold_low)\n",
+    "            )\n",
+    "        )\n",
+    "        # Cada puesto puntúa en base a su duración y a la inversa de la distancia (a menor distancia, mayor puntuación)\n",
+    "        df['position_score'] = round(((1 - df['adjusted_distance']) * (df['duration_capped']/req_experience) * 100), 2)\n",
+    "        # Descartamos puestos con distancia superior al umbral definido (asignamos puntuación 0), y ordenamos por puntuación\n",
+    "        df.loc[df['distancia'] >= dist_threshold_high, 'position_score'] = 0\n",
+    "        df = df.sort_values(by='position_score', ascending=False)\n",
+    "        # Nos quedamos con los puestos con mayor puntuación (positions_cap)\n",
+    "        df.iloc[positions_cap:, df.columns.get_loc('position_score')] = 0\n",
+    "        # Totalizamos (no debería superar 100 nunca, pero ponemos un límite para asegurar) y redondeamos a dos decimales\n",
+    "        total_score = round(min(df['position_score'].sum(), 100), 2)\n",
+    "        return df, total_score\n",
+    "    \n",
+    "    def filtra_experiencia_relevante(self, df):\n",
+    "        \"\"\"\n",
+    "        Filtra las experiencias relevantes del dataframe y las devuelve en formato diccionario.\n",
+    "        Args:\n",
+    "            df (pandas.DataFrame): DataFrame con la información completa de experiencia.\n",
+    "        Returns:\n",
+    "            dict: Diccionario con las experiencias relevantes.\n",
+    "        \"\"\"\n",
+    "        df_experiencia =  df[df['position_score'] > 0].copy()\n",
+    "        df_experiencia.drop(columns=['periodo', 'fec_inicio', 'fec_final', \n",
+    "                                     'distancia', 'duration_capped', 'adjusted_distance'], inplace=True)\n",
+    "        experiencia_dict = df_experiencia.to_dict(orient='list')\n",
+    "        return experiencia_dict\n",
+    "    \n",
+    "    def procesar_cv_completo(self, req_experience, positions_cap, dist_threshold_low, dist_threshold_high):\n",
+    "        \"\"\"\n",
+    "        Procesa un CV y calcula la puntuación final.\n",
+    "        Args:\n",
+    "            req_experience (int, optional): Experiencia requerida en meses para el puesto de trabajo.\n",
+    "            positions_cap (int, optional): Número máximo de puestos a considerar para la puntuación.\n",
+    "            dist_threshold_low (float, optional): Distancia límite para considerar un puesto equivalente.\n",
+    "            dist_threshold_high (float, optional): Distancia límite para considerar un puesto no relevante.\n",
+    "        Returns:\n",
+    "            pd.DataFrame: DataFrame con las puntuaciones individuales contribuidas por cada puesto.\n",
+    "            float: Puntuación total entre 0 y 100.\n",
+    "        \"\"\"\n",
+    "        df_datos_estructurados_cv = self.extraer_datos_cv()\n",
+    "        df_datos_estructurados_cv = self.procesar_periodos(df_datos_estructurados_cv)\n",
+    "        df_con_embeddings = self.calcular_embeddings(df_datos_estructurados_cv)\n",
+    "        df_con_distancias = self.calcular_distancias(df_con_embeddings)\n",
+    "        df_puntuaciones, puntuacion = self.calcular_puntuacion(df_con_distancias,\n",
+    "                                                                req_experience=req_experience,\n",
+    "                                                                positions_cap=positions_cap,\n",
+    "                                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                                dist_threshold_high=dist_threshold_high)\n",
+    "        dict_experiencia = self.filtra_experiencia_relevante(df_puntuaciones)\n",
+    "        return df_puntuaciones, puntuacion, dict_experiencia"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2. Proceso completo de cálculo de puntuación"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "En el siguiente bloque, podemos introducir cualquier texto de oferta, un CV, y obtener las puntuaciones y el DataFrame con los cálculos:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x00000159FCE43C90>\n",
+      "Puntuación: 89.0/100\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>empresa</th>\n",
+       "      <th>puesto</th>\n",
+       "      <th>periodo</th>\n",
+       "      <th>fec_inicio</th>\n",
+       "      <th>fec_final</th>\n",
+       "      <th>duracion</th>\n",
+       "      <th>distancia</th>\n",
+       "      <th>duration_capped</th>\n",
+       "      <th>adjusted_distance</th>\n",
+       "      <th>position_score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Mercadona</td>\n",
+       "      <td>Vendedor/a de puesto de mercado</td>\n",
+       "      <td>202310-202403</td>\n",
+       "      <td>2023-10-01</td>\n",
+       "      <td>2024-03-01</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>41.67</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>GASTROTEKA ORDIZIA 1990</td>\n",
+       "      <td>Camarero/a de barra</td>\n",
+       "      <td>202303-202309</td>\n",
+       "      <td>2023-03-01</td>\n",
+       "      <td>2023-09-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.59</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.18</td>\n",
+       "      <td>40.87</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>AGRISOLUTIONS</td>\n",
+       "      <td>AUXILIAR DE MANTENIMIENTO INDUSTRIAL</td>\n",
+       "      <td>202001-202401</td>\n",
+       "      <td>2020-01-01</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>48</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>12</td>\n",
+       "      <td>0.94</td>\n",
+       "      <td>6.47</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Autónomo</td>\n",
+       "      <td>Comercial de automoviles</td>\n",
+       "      <td>202401-202402</td>\n",
+       "      <td>2024-01-01</td>\n",
+       "      <td>2024-02-01</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.63</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Bellota Herramientas</td>\n",
+       "      <td>Personal de mantenimiento</td>\n",
+       "      <td>202005-202011</td>\n",
+       "      <td>2020-05-01</td>\n",
+       "      <td>2020-11-01</td>\n",
+       "      <td>6</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>ZEREGUIN ZERBITZUAK</td>\n",
+       "      <td>limpieza industrial</td>\n",
+       "      <td>202012-202305</td>\n",
+       "      <td>2020-12-01</td>\n",
+       "      <td>2023-05-01</td>\n",
+       "      <td>29</td>\n",
+       "      <td>0.70</td>\n",
+       "      <td>12</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>0.00</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   empresa                                puesto  \\\n",
+       "1                Mercadona       Vendedor/a de puesto de mercado   \n",
+       "3  GASTROTEKA ORDIZIA 1990                   Camarero/a de barra   \n",
+       "2            AGRISOLUTIONS  AUXILIAR DE MANTENIMIENTO INDUSTRIAL   \n",
+       "0                 Autónomo              Comercial de automoviles   \n",
+       "5     Bellota Herramientas             Personal de mantenimiento   \n",
+       "4      ZEREGUIN ZERBITZUAK                   limpieza industrial   \n",
+       "\n",
+       "         periodo  fec_inicio   fec_final  duracion  distancia  \\\n",
+       "1  202310-202403  2023-10-01  2024-03-01         5       0.56   \n",
+       "3  202303-202309  2023-03-01  2023-09-01         6       0.59   \n",
+       "2  202001-202401  2020-01-01  2024-01-01        48       0.62   \n",
+       "0  202401-202402  2024-01-01  2024-02-01         1       0.63   \n",
+       "5  202005-202011  2020-05-01  2020-11-01         6       0.65   \n",
+       "4  202012-202305  2020-12-01  2023-05-01        29       0.70   \n",
+       "\n",
+       "   duration_capped  adjusted_distance  position_score  \n",
+       "1                5               0.00           41.67  \n",
+       "3                6               0.18           40.87  \n",
+       "2               12               0.94            6.47  \n",
+       "0                1               1.00            0.00  \n",
+       "5                6               1.00            0.00  \n",
+       "4               12               1.00            0.00  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'empresa': ['Mercadona', 'GASTROTEKA ORDIZIA 1990', 'AGRISOLUTIONS'], 'puesto': ['Vendedor/a de puesto de mercado', 'Camarero/a de barra', 'AUXILIAR DE MANTENIMIENTO INDUSTRIAL'], 'duracion': [5, 6, 48], 'position_score': [41.67, 40.87, 6.47]}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Definimos la oferta de trabajo:\n",
+    "job_text = \"Cajero supermercado Dia\"\n",
+    "\n",
+    "# Cargamos el esquema:\n",
+    "with open('../json/ner_schema.json', 'r', encoding='utf-8') as schema_file:\n",
+    "    ner_schema = json.load(schema_file)\n",
+    "\n",
+    "# Cargamos el CV:\n",
+    "cv_sample_path = '../../ejemplos_cvs/cv_sample.txt' # Ruta al fichero de texto con un currículo de ejemplo\n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "\n",
+    "# Cargamos el prompt para NER:\n",
+    "with open('../prompts/ner_pre_prompt.txt', 'r', encoding='utf-8') as file:\n",
+    "    ner_pre_prompt = file.read()\n",
+    "\n",
+    "procesador_cvs = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, ner_schema)\n",
+    "req_experience = 12 # Experiencia requerida en meses\n",
+    "positions_cap=4 # Número máximo de puestos a considerar\n",
+    "dist_threshold_low=0.58 # Distancia límite para considerar un puesto equivalente\n",
+    "dist_threshold_high=0.62 # Distancia límite para considerar un puesto no relevante\n",
+    "df_puntuaciones, puntuacion, dict_experiencia = procesador_cvs.procesar_cv_completo(req_experience=req_experience,\n",
+    "                                                positions_cap=positions_cap,\n",
+    "                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                dist_threshold_high=dist_threshold_high\n",
+    "                                                )\n",
+    "\n",
+    "print(f\"Puntuación: {puntuacion:.1f}/100\")\n",
+    "pd.options.display.float_format = '{:,.2f}'.format\n",
+    "display(df_puntuaciones)\n",
+    "pd.reset_option('display.float_format')\n",
+    "print(dict_experiencia)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3. Llamada final al modelo de lenguaje"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x00000159FCC15250>\n"
+     ]
+    }
+   ],
+   "source": [
+    "client = OpenAI(api_key=api_key)\n",
+    "print(\"Cliente inicializado como\",client)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Definimos un esquema para la respuesta final:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "response_schema = {\n",
+    "    \"type\": \"object\",\n",
+    "    \"properties\": {\n",
+    "        \"puntuacion\": {\"type\": \"number\"},\n",
+    "        \"experiencia\": {\n",
+    "            \"type\": \"array\",\n",
+    "            \"items\": {\n",
+    "                \"type\": \"object\",\n",
+    "                \"properties\": {\n",
+    "                    \"empresa\": {\"type\": \"string\"},\n",
+    "                    \"puesto\": {\"type\": \"string\"},\n",
+    "                    \"duracion\": {\"type\": \"integer\"}\n",
+    "                },\n",
+    "                \"required\": [\"empresa\", \"puesto\", \"duracion\"]\n",
+    "            }\n",
+    "        },\n",
+    "        \"descripcion de la experiencia\": {\"type\": \"string\"}\n",
+    "    },\n",
+    "    \"required\": [\"puntuacion\", \"experiencia relevante\", \"descripcion de la experiencia\"]\n",
+    "}\n",
+    "\n",
+    "# Guardamos el esquema en un fichero JSON\n",
+    "with open('../json/response_schema.json', 'w', encoding='utf-8') as f:\n",
+    "    json.dump(response_schema, f, ensure_ascii=False, indent=4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'type': 'object', 'properties': {'puntuacion': {'type': 'number'}, 'experiencia': {'type': 'array', 'items': {'type': 'object', 'properties': {'empresa': {'type': 'string'}, 'puesto': {'type': 'string'}, 'duracion': {'type': 'integer'}}, 'required': ['empresa', 'puesto', 'duracion']}}, 'descripcion de la experiencia': {'type': 'string'}}, 'required': ['puntuacion', 'experiencia relevante', 'descripcion de la experiencia']}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Recuperamos el esquema desde el fichero JSON guardado (para comprobar que funciona, ya que el código final utilizará el fichero)\n",
+    "with open('../json/response_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    response_schema = json.load(f)\n",
+    "\n",
+    "print(response_schema)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Creamos un \"system prompt\" (instrucción general) y un \"user prompt\" (instrucción con contexto específico: puntuación y datos estructurados) para la inferencia final:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "system_prompt = (\"Eres un procesador de currículos vitae que recibe una oferta de trabajo un currículum vitae filtrado \"\n",
+    "                \"la experiencia relevante previa, una puntuación precalculada para el currículo entre 0 y 100, \"\n",
+    "                \"y un parámetro de experiencia requerida en meses. \"\n",
+    "                \"La puntuación se ha calculado mediante un algoritmo que usa distancias de embeddings entre cada uno de los puestos \"\n",
+    "                \"y la definición de la oferta, así como la duración de cada puesto y su relación con el parámetro de experiencia requerida. \"\n",
+    "                \"Devuelves un objeto con el esquema predefinido,\"\n",
+    "                \"incluyendo exactamente la misma puntuación proporcionada, el listado de experiencia proporcionado \"\n",
+    "                \"y además devuelves un breve texto explicativo sobre la experiencia del candidato y  \"\n",
+    "                \"por qué ha obtenido la puntuación dada. Es importante que el texto explicativo sea coherente con la puntuación. \"\n",
+    "                \"Por ejemplo, si la puntuación es mayor que 80, el texto explicativo debe hacer énfasis en las experiencias pasadas \"\n",
+    "                \"y la duración de las mismas que han llevado a esa puntuación. \"\n",
+    "                \"Cuando menciones algo en relación a la duración de la experiencia, asegúrate de convertirlo a años si es mayor que 12 meses.\"\n",
+    "            )\n",
+    "\n",
+    "user_prompt = (\"El título de la oferta de trabajo es: {job}.\" \n",
+    "               \"La experiencia requerida en meses es: {req_experience}.\" \n",
+    "               \"La puntuacion es {puntuacion}, \"\n",
+    "               \"La experiencia relevante es: {exp}. \"\n",
+    "               \"Explica por qué se ha obtenido la puntuación\"\n",
+    "               )\n",
+    "\n",
+    "\n",
+    "# Los guardamos en ficheros de texto para simplificar el código y facilitar su mantenimiento y edición:\n",
+    "with open('../prompts/system_prompt.txt', 'w', encoding='utf-8') as f:\n",
+    "    f.write(system_prompt)\n",
+    "\n",
+    "with open('../prompts/user_prompt.txt', 'w', encoding='utf-8') as f:\n",
+    "    f.write(user_prompt)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "### System prompt ###\n",
+      "Eres un procesador de currículos vitae que recibe una oferta de trabajo un currículum vitae filtrado la experiencia\n",
+      "relevante previa, una puntuación precalculada para el currículo entre 0 y 100, y un parámetro de experiencia requerida\n",
+      "en meses. La puntuación se ha calculado mediante un algoritmo que usa distancias de embeddings entre cada uno de los\n",
+      "puestos y la definición de la oferta, así como la duración de cada puesto y su relación con el parámetro de experiencia\n",
+      "requerida. Devuelves un objeto con el esquema predefinido,incluyendo exactamente la misma puntuación proporcionada, el\n",
+      "listado de experiencia proporcionado y además devuelves un breve texto explicativo sobre la experiencia del candidato y\n",
+      "por qué ha obtenido la puntuación dada. Es importante que el texto explicativo sea coherente con la puntuación. Por\n",
+      "ejemplo, si la puntuación es mayor que 80, el texto explicativo debe hacer énfasis en las experiencias pasadas y la\n",
+      "duración de las mismas que han llevado a esa puntuación. Cuando menciones algo en relación a la duración de la\n",
+      "experiencia, asegúrate de convertirlo a años si es mayor que 12 meses.\n",
+      "\n",
+      "### User prompt ###\n",
+      "El título de la oferta de trabajo es: Cajero supermercado Dia.La experiencia requerida en meses es: 12.La puntuacion es\n",
+      "89.01, La experiencia relevante es: {'empresa': ['Mercadona', 'GASTROTEKA ORDIZIA 1990', 'AGRISOLUTIONS'], 'puesto':\n",
+      "['Vendedor/a de puesto de mercado', 'Camarero/a de barra', 'AUXILIAR DE MANTENIMIENTO INDUSTRIAL'], 'duracion': [5, 6,\n",
+      "48], 'position_score': [41.67, 40.87, 6.47]}. Explica por qué se ha obtenido la puntuación\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Recuperamos los ficheros guardados para comprobar que están bien:\n",
+    "with open('../prompts/system_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    system_prompt = f.read()\n",
+    "\n",
+    "with open('../prompts/user_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    user_prompt = f.read()\n",
+    "\n",
+    "print(\"### System prompt ###\")\n",
+    "print(textwrap.fill(system_prompt, width=120))\n",
+    "# En el caso del prompt del usuario, el texto contiene variables que serán reemplazadas por los valores correspondientes.\n",
+    "# Por ejemplo, usamos las definidas en este notebook para visualizar el texto que finalmente recibirá el modelo.\n",
+    "print(\"\\n### User prompt ###\")\n",
+    "user_prompt_con_contexto = user_prompt.format(job=job_text, req_experience=req_experience,puntuacion=puntuacion, exp=dict_experiencia)\n",
+    "print(textwrap.fill(user_prompt_con_contexto, width=120))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Respuesta:\n",
+      " {\n",
+      "    \"puntuacion\": 89.01,\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "            \"duracion\": 5\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "            \"puesto\": \"Camarero/a de barra\",\n",
+      "            \"duracion\": 6\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"AGRISOLUTIONS\",\n",
+      "            \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "            \"duracion\": 48\n",
+      "        }\n",
+      "    ],\n",
+      "    \"descripcion de la experiencia\": \"El candidato ha acumulado una sólida experiencia en atención al cliente y manejo de operaciones de caja, especialmente a través de su trabajo en Mercadona como Vendedor/a de puesto de mercado durante 5 meses. Además, su paso por GASTROTEKA ORDIZIA 1990 como Camarero/a de barra durante 6 meses le ha permitido desarrollar habilidades interpersonales y de servicio al cliente. Por último, su experiencia de 48 meses en AGRISOLUTIONS como Auxiliar de Mantenimiento Industrial, aunque no directamente relacionada con el puesto de cajero, demuestra una sólida ética de trabajo y capacidad para adaptarse a diferentes entornos laborales. La combinación de estas experiencias ha llevado a una puntuación alta de 89.01, reflejando una adecuada preparación para el puesto.\"\n",
+      "}\n",
+      "Descripción de la experiencia:\n",
+      "El candidato ha acumulado una sólida experiencia en atención al cliente y manejo de operaciones de caja, especialmente a\n",
+      "través de su trabajo en Mercadona como Vendedor/a de puesto de mercado durante 5 meses. Además, su paso por GASTROTEKA\n",
+      "ORDIZIA 1990 como Camarero/a de barra durante 6 meses le ha permitido desarrollar habilidades interpersonales y de\n",
+      "servicio al cliente. Por último, su experiencia de 48 meses en AGRISOLUTIONS como Auxiliar de Mantenimiento Industrial,\n",
+      "aunque no directamente relacionada con el puesto de cajero, demuestra una sólida ética de trabajo y capacidad para\n",
+      "adaptarse a diferentes entornos laborales. La combinación de estas experiencias ha llevado a una puntuación alta de\n",
+      "89.01, reflejando una adecuada preparación para el puesto.\n"
+     ]
+    }
+   ],
+   "source": [
+    "messages = [\n",
+    "    {\n",
+    "        \"role\": \"system\",\n",
+    "        \"content\": system_prompt\n",
+    "    },\n",
+    "    {\n",
+    "        \"role\": \"user\",\n",
+    "        \"content\": user_prompt.format(job=job_text, req_experience=req_experience,puntuacion=puntuacion, exp=dict_experiencia)\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "functions = [\n",
+    "    {\n",
+    "        \"name\": \"respuesta_formateada\",\n",
+    "        \"description\": \"Devuelve el objeto con puntuacion, experiencia y descripcion de la experiencia\",\n",
+    "        \"parameters\": response_schema\n",
+    "    }\n",
+    "]\n",
+    "\n",
+    "response = client.chat.completions.create(\n",
+    "    model=\"gpt-4o-mini\",\n",
+    "    temperature=0.5,\n",
+    "    messages=messages,\n",
+    "    functions=functions,\n",
+    "    function_call={\"name\": \"respuesta_formateada\"}\n",
+    ")\n",
+    "\n",
+    "if response.choices[0].message.function_call:\n",
+    "    function_call = response.choices[0].message.function_call\n",
+    "    structured_output = json.loads(function_call.arguments)\n",
+    "    print(\"Respuesta:\\n\", json.dumps(structured_output, indent=4, ensure_ascii=False))\n",
+    "    wrapped_description = textwrap.fill(structured_output['descripcion de la experiencia'], width=120)\n",
+    "    print(f\"Descripción de la experiencia:\\n{wrapped_description}\")\n",
+    "else:\n",
+    "    print(\"Error:\", response.choices[0].message.content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 4. Prueba final del código completo"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Una vez comprobado el proceso completo, podemos encapsular todo el código en la clase definida al inicio de este notebook. Finalmente, guardaremos el módulo en un fichero .py al que llamará la interfaz de usuario a diseñar en el próximo notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ProcesadorCV:\n",
+    "\n",
+    "    def __init__(self, api_key, cv_text, job_text, ner_pre_prompt, system_prompt, user_prompt, ner_schema, response_schema,\n",
+    "                inference_model=\"gpt-4o-mini\", embeddings_model=\"text-embedding-3-small\"):\n",
+    "        \"\"\"\n",
+    "        Inicializa una instancia de la clase con los parámetros proporcionados.\n",
+    "\n",
+    "        Args:\n",
+    "            api_key (str): La clave de API para autenticar con el cliente OpenAI.\n",
+    "            cv_text (str): contenido del CV en formato de texto.\n",
+    "            job_text (str): título de la oferta de trabajo a evaluar.\n",
+    "            ner_pre_prompt (str): instrucción de \"reconocimiento de entidades nombradas\" (NER) para el modelo en lenguaje natural.\n",
+    "            system_prompt (str): instrucción en lenguaje natural para la salida estructurada final.\n",
+    "            user_prompt (str): instrucción con los parámetros y datos calculados en el preprocesamiento.\n",
+    "            ner_schema (dict): esquema para la llamada con \"structured outputs\" al modelo de OpenAI para NER.\n",
+    "            response_schema (dict): esquema para la respuesta final de la aplicación.\n",
+    "            inference_model (str, opcional): El modelo de inferencia a utilizar. Por defecto es \"gpt-4o-mini\".\n",
+    "            embeddings_model (str, opcional): El modelo de embeddings a utilizar. Por defecto es \"text-embedding-3-small\".\n",
+    "\n",
+    "        Atributos:\n",
+    "            inference_model (str): Almacena el modelo de inferencia seleccionado.\n",
+    "            embeddings_model (str): Almacena el modelo de embeddings seleccionado.\n",
+    "            client (OpenAI): Instancia del cliente OpenAI inicializada con la clave de API proporcionada.\n",
+    "            cv (str): Almacena el texto del currículum vitae proporcionado.\n",
+    "\n",
+    "        \"\"\"\n",
+    "        self.inference_model = inference_model\n",
+    "        self.embeddings_model = embeddings_model\n",
+    "        self.ner_pre_prompt = ner_pre_prompt\n",
+    "        self.user_prompt = user_prompt\n",
+    "        self.system_prompt = system_prompt\n",
+    "        self.ner_schema = ner_schema\n",
+    "        self.response_schema = response_schema\n",
+    "        self.client = OpenAI(api_key=api_key)\n",
+    "        self.cv = cv_text\n",
+    "        self.job_text = job_text\n",
+    "        print(\"Cliente inicializado como\",self.client)\n",
+    "\n",
+    "    def extraer_datos_cv(self, temperature=0.5):\n",
+    "        \"\"\"\n",
+    "        Extrae datos estructurados de un CV con OpenAI API.\n",
+    "        Args:\n",
+    "            pre_prompt (str): instrucción para el modelo en lenguaje natural.\n",
+    "            schema (dict): esquema de los parámetros que se espera extraer del CV.\n",
+    "            temperature (float, optional): valor de temperatura para el modelo de lenguaje. Por defecto es 0.5.\n",
+    "        Returns:\n",
+    "            pd.DataFrame: DataFrame con los datos estructurados extraídos del CV.\n",
+    "        Raises:\n",
+    "            ValueError: si no se pueden extraer datos estructurados del CV.\n",
+    "        \"\"\"\n",
+    "        response = self.client.chat.completions.create(\n",
+    "            model=self.inference_model,\n",
+    "            temperature=temperature,\n",
+    "            messages=[\n",
+    "                {\"role\": \"system\", \"content\": self.ner_pre_prompt},\n",
+    "                {\"role\": \"user\", \"content\": self.cv}\n",
+    "            ],\n",
+    "            functions=[\n",
+    "                {\n",
+    "                    \"name\": \"extraer_datos_cv\",\n",
+    "                    \"description\": \"Extrae tabla con títulos de puesto de trabajo, nombres de empresa y períodos de un CV.\",\n",
+    "                    \"parameters\": self.ner_schema\n",
+    "                }\n",
+    "            ],\n",
+    "            function_call=\"auto\"\n",
+    "        )\n",
+    "\n",
+    "        if response.choices[0].message.function_call:\n",
+    "            function_call = response.choices[0].message.function_call\n",
+    "            structured_output = json.loads(function_call.arguments)\n",
+    "            if structured_output.get(\"experiencia\"):\n",
+    "                df_cv = pd.DataFrame(structured_output[\"experiencia\"]) \n",
+    "                return df_cv\n",
+    "            else:\n",
+    "                raise ValueError(f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\")\n",
+    "        else:\n",
+    "            raise ValueError(f\"No se han podido extraer datos estructurados: {response.choices[0].message.content}\")\n",
+    "        \n",
+    "\n",
+    "    def procesar_periodos(self, df):    \n",
+    "        \"\"\"\n",
+    "        Procesa los períodos en un DataFrame y añade columnas con las fechas de inicio, fin y duración en meses. \n",
+    "        Si no hay fecha de fin, se considera la fecha actual.\n",
+    "        Args:\n",
+    "            df (pandas.DataFrame): DataFrame que contiene una columna 'periodo' con períodos en formato 'YYYYMM-YYYYMM' o 'YYYYMM'.\n",
+    "        Returns:\n",
+    "            pandas.DataFrame: DataFrame con columnas adicionales 'fec_inicio', 'fec_final' y 'duracion'.\n",
+    "                - 'fec_inicio' (datetime.date): Fecha de inicio del período.\n",
+    "                - 'fec_final' (datetime.date): Fecha de fin del período.\n",
+    "                - 'duracion' (int): Duración del período en meses.\n",
+    "        \"\"\"\n",
+    "        # Función lambda para procesar el período\n",
+    "        def split_periodo(periodo):\n",
+    "            dates = periodo.split('-')\n",
+    "            start_date = datetime.strptime(dates[0], \"%Y%m\")\n",
+    "            if len(dates) > 1:\n",
+    "                end_date = datetime.strptime(dates[1], \"%Y%m\")\n",
+    "            else:\n",
+    "                end_date = datetime.now()\n",
+    "            return start_date, end_date\n",
+    "\n",
+    "        df[['fec_inicio', 'fec_final']] = df['periodo'].apply(lambda x: pd.Series(split_periodo(x)))\n",
+    "\n",
+    "        # Formateamos las fechas para mostrar mes, año, y el primer día del mes (dado que el día es irrelevante y no se suele especificar)\n",
+    "        df['fec_inicio'] = df['fec_inicio'].dt.date\n",
+    "        df['fec_final'] = df['fec_final'].dt.date\n",
+    "\n",
+    "        # Añadimos una columna con la duración en meses\n",
+    "        df['duracion'] = df.apply(\n",
+    "            lambda row: (row['fec_final'].year - row['fec_inicio'].year) * 12 + \n",
+    "                        row['fec_final'].month - row['fec_inicio'].month, \n",
+    "            axis=1\n",
+    "        )\n",
+    "\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_embeddings(self, df, column='puesto', model_name='text-embedding-3-small'):\n",
+    "        \"\"\"\n",
+    "        Calcula los embeddings de una columna de un dataframe con OpenAI API.\n",
+    "        Args:\n",
+    "            cv_df (pandas.DataFrame): DataFrame con los datos de los CV.\n",
+    "            column (str, optional): Nombre de la columna que contiene los datos a convertir en embeddings. Por defecto es 'puesto'.\n",
+    "            model_name (str, optional): Nombre del modelo de embeddings. Por defecto es 'text-embedding-3-small'.\n",
+    "        \"\"\"\n",
+    "        df['embeddings'] = df[column].apply(\n",
+    "            lambda puesto: self.client.embeddings.create(\n",
+    "                input=puesto, \n",
+    "                model=model_name\n",
+    "            ).data[0].embedding\n",
+    "        )\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_distancias(self, df, column='embeddings', model_name='text-embedding-3-small'):\n",
+    "        \"\"\"\n",
+    "        Calcula la distancia coseno entre los embeddings del texto y los incluidos en una columna del dataframe.\n",
+    "        Params:\n",
+    "        df (pandas.DataFrame): DataFrame que contiene los embeddings.\n",
+    "        column (str, optional): nombre de la columna del DataFrame que contiene los embeddings. Por defecto, 'embeddings'.\n",
+    "        model_name (str, optional): modelo de embeddings de la API de OpenAI. Por defecto \"text-embedding-3-small\".\n",
+    "        Returns:\n",
+    "        pandas.DataFrame: DataFrame ordenado de menor a mayor distancia, con las distancias en una nueva columna.\n",
+    "        \"\"\"\n",
+    "        response = self.client.embeddings.create(\n",
+    "            input=self.job_text,\n",
+    "            model=model_name\n",
+    "        )\n",
+    "        emb_compare = response.data[0].embedding\n",
+    "\n",
+    "        df['distancia'] = df[column].apply(lambda emb: spatial.distance.cosine(emb, emb_compare))\n",
+    "        df.drop(columns=[column], inplace=True)\n",
+    "        df.sort_values(by='distancia', ascending=True, inplace=True)\n",
+    "        return df\n",
+    "\n",
+    "\n",
+    "    def calcular_puntuacion(self, df, req_experience, positions_cap=4, dist_threshold_low=0.6, dist_threshold_high=0.7):\n",
+    "        \"\"\"\n",
+    "        Calcula la puntuación de un CV a partir de su tabla de distancias (con respecto a un puesto dado) y duraciones. \n",
+    "\n",
+    "        Params:\n",
+    "        df (pandas.DataFrame): datos de un CV incluyendo diferentes experiencias incluyendo duracies y distancia previamente calculadas sobre los embeddings de un puesto de trabajo\n",
+    "        req_experience (float): experiencia requerida en meses para el puesto de trabajo (valor de referencia para calcular una puntuación entre 0 y 100 en base a diferentes experiencias)\n",
+    "        positions_cap (int, optional): Maximum number of positions to consider for scoring. Defaults to 4.\n",
+    "        dist_threshold_low (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV se considera \"equivalente\" al de la oferta.\n",
+    "        max_dist_threshold (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV no puntúa.\n",
+    "        \n",
+    "        Returns:\n",
+    "        pandas.DataFrame: DataFrame original añadiendo una columna con las puntuaciones individuales contribuidas por cada puesto.\n",
+    "        float: Puntuación total entre 0 y 100.\n",
+    "        \"\"\"\n",
+    "        # A efectos de puntuación, computamos para cada puesto como máximo el número total de meses de experiencia requeridos\n",
+    "        df['duration_capped'] = df['duracion'].apply(lambda x: min(x, req_experience))\n",
+    "        # Normalizamos la distancia entre 0 y 1, siendo 0 la distancia mínima y 1 la máxima\n",
+    "        df['adjusted_distance'] = df['distancia'].apply(\n",
+    "            lambda x: 0 if x <= dist_threshold_low else (\n",
+    "                1 if x >= dist_threshold_high else (x - dist_threshold_low) / (dist_threshold_high - dist_threshold_low)\n",
+    "            )\n",
+    "        )\n",
+    "        # Cada puesto puntúa en base a su duración y a la inversa de la distancia (a menor distancia, mayor puntuación)\n",
+    "        df['position_score'] = round(((1 - df['adjusted_distance']) * (df['duration_capped']/req_experience) * 100), 2)\n",
+    "        # Descartamos puestos con distancia superior al umbral definido (asignamos puntuación 0), y ordenamos por puntuación\n",
+    "        df.loc[df['distancia'] >= dist_threshold_high, 'position_score'] = 0\n",
+    "        df = df.sort_values(by='position_score', ascending=False)\n",
+    "        # Nos quedamos con los puestos con mayor puntuación (positions_cap)\n",
+    "        df.iloc[positions_cap:, df.columns.get_loc('position_score')] = 0\n",
+    "        # Totalizamos (no debería superar 100 nunca, pero ponemos un límite para asegurar) y redondeamos a dos decimales\n",
+    "        total_score = round(min(df['position_score'].sum(), 100), 2)\n",
+    "        return df, total_score\n",
+    "    \n",
+    "    def filtra_experiencia_relevante(self, df):\n",
+    "        \"\"\"\n",
+    "        Filtra las experiencias relevantes del dataframe y las devuelve en formato diccionario.\n",
+    "        Args:\n",
+    "            df (pandas.DataFrame): DataFrame con la información completa de experiencia.\n",
+    "        Returns:\n",
+    "            dict: Diccionario con las experiencias relevantes.\n",
+    "        \"\"\"\n",
+    "        df_experiencia =  df[df['position_score'] > 0].copy()\n",
+    "        df_experiencia.drop(columns=['periodo', 'fec_inicio', 'fec_final', \n",
+    "                                     'distancia', 'duration_capped', 'adjusted_distance'], inplace=True)\n",
+    "        experiencia_dict = df_experiencia.to_dict(orient='list')\n",
+    "        return experiencia_dict\n",
+    "    \n",
+    "    def llamada_final(self, req_experience, puntuacion, dict_experiencia):\n",
+    "        \"\"\"\n",
+    "        Realiza la llamada final al modelo de lenguaje para generar la respuesta final.\n",
+    "        Args:\n",
+    "        req_experience (int): Experiencia requerida en meses para el puesto de trabajo.\n",
+    "        puntuacion (float): Puntuación total del CV.\n",
+    "        dict_experiencia (dict): Diccionario con las experiencias relevantes.\n",
+    "        Returns:\n",
+    "        dict: Diccionario con la respuesta final.\n",
+    "        \"\"\"\n",
+    "        messages = [\n",
+    "            {\n",
+    "                \"role\": \"system\",\n",
+    "                \"content\": self.system_prompt\n",
+    "            },\n",
+    "            {\n",
+    "                \"role\": \"user\",\n",
+    "                \"content\": self.user_prompt.format(job=self.job_text, req_experience=req_experience,puntuacion=puntuacion, exp=dict_experiencia)\n",
+    "            }\n",
+    "        ]\n",
+    "\n",
+    "        functions = [\n",
+    "            {\n",
+    "                \"name\": \"respuesta_formateada\",\n",
+    "                \"description\": \"Devuelve el objeto con puntuacion, experiencia y descripcion de la experiencia\",\n",
+    "                \"parameters\": self.response_schema\n",
+    "            }\n",
+    "        ]\n",
+    "\n",
+    "        response = self.client.chat.completions.create(\n",
+    "            model=self.inference_model,\n",
+    "            temperature=0.5,\n",
+    "            messages=messages,\n",
+    "            functions=functions,\n",
+    "            function_call={\"name\": \"respuesta_formateada\"}\n",
+    "        )\n",
+    "\n",
+    "        if response.choices[0].message.function_call:\n",
+    "            function_call = response.choices[0].message.function_call\n",
+    "            structured_output = json.loads(function_call.arguments)\n",
+    "            print(\"Respuesta:\\n\", json.dumps(structured_output, indent=4, ensure_ascii=False))\n",
+    "            wrapped_description = textwrap.fill(structured_output['descripcion de la experiencia'], width=120)\n",
+    "            print(f\"Descripción de la experiencia:\\n{wrapped_description}\")\n",
+    "            return structured_output\n",
+    "        else:\n",
+    "            raise ValueError(f\"Error. No se ha podido generar respuesta:\\n {response.choices[0].message.content}\")\n",
+    "    \n",
+    "    def procesar_cv_completo(self, req_experience, positions_cap, dist_threshold_low, dist_threshold_high):\n",
+    "        \"\"\"\n",
+    "        Procesa un CV y calcula la puntuación final.\n",
+    "        Args:\n",
+    "            req_experience (int, optional): Experiencia requerida en meses para el puesto de trabajo.\n",
+    "            positions_cap (int, optional): Número máximo de puestos a considerar para la puntuación.\n",
+    "            dist_threshold_low (float, optional): Distancia límite para considerar un puesto equivalente.\n",
+    "            dist_threshold_high (float, optional): Distancia límite para considerar un puesto no relevante.\n",
+    "        Returns:\n",
+    "            pd.DataFrame: DataFrame con las puntuaciones individuales contribuidas por cada puesto.\n",
+    "            float: Puntuación total entre 0 y 100.\n",
+    "        \"\"\"\n",
+    "        df_datos_estructurados_cv = self.extraer_datos_cv()\n",
+    "        df_datos_estructurados_cv = self.procesar_periodos(df_datos_estructurados_cv)\n",
+    "        df_con_embeddings = self.calcular_embeddings(df_datos_estructurados_cv)\n",
+    "        df_con_distancias = self.calcular_distancias(df_con_embeddings)\n",
+    "        df_puntuaciones, puntuacion = self.calcular_puntuacion(df_con_distancias,\n",
+    "                                                                req_experience=req_experience,\n",
+    "                                                                positions_cap=positions_cap,\n",
+    "                                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                                dist_threshold_high=dist_threshold_high)\n",
+    "        dict_experiencia = self.filtra_experiencia_relevante(df_puntuaciones)\n",
+    "        dict_respuesta = self.llamada_final(req_experience, puntuacion, dict_experiencia)\n",
+    "        return dict_respuesta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x00000159FD143790>\n",
+      "Respuesta:\n",
+      " {\n",
+      "    \"puntuacion\": 68.6,\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"AGRISOLUTIONS\",\n",
+      "            \"puesto\": \"AUXILIAR DE MANTENIMIENTO INDUSTRIAL\",\n",
+      "            \"duracion\": 48\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Mercadona\",\n",
+      "            \"puesto\": \"Vendedor/a de puesto de mercado\",\n",
+      "            \"duracion\": 5\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"GASTROTEKA ORDIZIA 1990\",\n",
+      "            \"puesto\": \"Camarero/a de barra\",\n",
+      "            \"duracion\": 6\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Autónomo\",\n",
+      "            \"puesto\": \"Comercial de automoviles\",\n",
+      "            \"duracion\": 1\n",
+      "        }\n",
+      "    ],\n",
+      "    \"descripcion de la experiencia\": \"El candidato cuenta con una experiencia total de aproximadamente 4 años en diferentes roles, aunque su experiencia más relevante para el puesto de cajero en supermercado es limitada. Ha trabajado como vendedor en Mercadona y en un puesto de mercado, lo que le ha proporcionado habilidades de atención al cliente y manejo de efectivo, aunque la duración de estos puestos es relativamente corta. Además, su experiencia como auxiliar de mantenimiento industrial y en el sector de la hostelería, aunque no directamente relacionada, le ha otorgado habilidades valiosas en el trato con el público y en la gestión de situaciones de presión. La puntuación de 68.6 refleja una experiencia que, aunque no cumple con los 24 meses requeridos, muestra un potencial en el área de atención al cliente y ventas.\"\n",
+      "}\n",
+      "Descripción de la experiencia:\n",
+      "El candidato cuenta con una experiencia total de aproximadamente 4 años en diferentes roles, aunque su experiencia más\n",
+      "relevante para el puesto de cajero en supermercado es limitada. Ha trabajado como vendedor en Mercadona y en un puesto\n",
+      "de mercado, lo que le ha proporcionado habilidades de atención al cliente y manejo de efectivo, aunque la duración de\n",
+      "estos puestos es relativamente corta. Además, su experiencia como auxiliar de mantenimiento industrial y en el sector de\n",
+      "la hostelería, aunque no directamente relacionada, le ha otorgado habilidades valiosas en el trato con el público y en\n",
+      "la gestión de situaciones de presión. La puntuación de 68.6 refleja una experiencia que, aunque no cumple con los 24\n",
+      "meses requeridos, muestra un potencial en el área de atención al cliente y ventas.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Parámetros de ejecución:\n",
+    "job_text = \"Cajero supermercado Dia\"\n",
+    "cv_sample_path = '../../ejemplos_cvs/cv_sample.txt' # Ruta al fichero de texto con un currículo de ejemplo\n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "# Prompts:\n",
+    "with open('../prompts/ner_pre_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    ner_pre_prompt = f.read()\n",
+    "with open('../prompts/system_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    system_prompt = f.read()\n",
+    "with open('../prompts/user_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    user_prompt = f.read()\n",
+    "# Esquemas JSON:\n",
+    "with open('../json/ner_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    ner_schema = json.load(f)\n",
+    "with open('../json/response_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    response_schema = json.load(f)\n",
+    "\n",
+    "\n",
+    "procesador_cvs_prueba_final = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, \n",
+    "                                           system_prompt, user_prompt, ner_schema, response_schema)\n",
+    "req_experience = 24 # Experiencia requerida en meses\n",
+    "positions_cap=4 # Número máximo de puestos a considerar\n",
+    "dist_threshold_low=0.55 # Distancia límite para considerar un puesto equivalente\n",
+    "dist_threshold_high=0.65 # Distancia límite para considerar un puesto no relevante\n",
+    "dict_respuesta = procesador_cvs_prueba_final.procesar_cv_completo(req_experience=req_experience,\n",
+    "                                                positions_cap=positions_cap,\n",
+    "                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                dist_threshold_high=dist_threshold_high\n",
+    "                                                )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Probamos con otro ejemplo:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x00000159FD143750>\n",
+      "Respuesta:\n",
+      " {\n",
+      "    \"puntuacion\": 100,\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Talking to Chatbots, by Reddgr\",\n",
+      "            \"puesto\": \"Web Publisher and Generative AI Researcher\",\n",
+      "            \"duracion\": 206\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Relationship Manager | Cognitive Solutions SaaS\",\n",
+      "            \"duracion\": 43\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Acoustic\",\n",
+      "            \"puesto\": \"Principal Consultant | Martech SaaS\",\n",
+      "            \"duracion\": 35\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Engagement Manager, in support of Acoustic | B2B SaaS Retail Analytics\",\n",
+      "            \"duracion\": 10\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Engagement Manager | B2B SaaS Retail Analytics\",\n",
+      "            \"duracion\": 9\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"MBD Analytics\",\n",
+      "            \"puesto\": \"Business Intelligence Consultant\",\n",
+      "            \"duracion\": 10\n",
+      "        }\n",
+      "    ],\n",
+      "    \"descripcion de la experiencia\": \"El candidato ha obtenido una puntuación perfecta de 100 gracias a su extensa y relevante experiencia en el campo de la inteligencia artificial generativa y tecnologías relacionadas. Con más de 17 años de experiencia acumulada, ha trabajado en puestos clave como Web Publisher y Generative AI Researcher en 'Talking to Chatbots, by Reddgr', donde su enfoque en la investigación de IA generativa ha sido fundamental. Además, su trayectoria en IBM, donde ocupó roles en soluciones cognitivas y análisis minorista, ha reforzado su conocimiento en SaaS y su capacidad para gestionar relaciones con clientes en entornos tecnológicos avanzados. La combinación de estas experiencias, junto con su sólida formación en consultoría y análisis de datos, lo posiciona como un candidato excepcionalmente calificado para el puesto.\"\n",
+      "}\n",
+      "Descripción de la experiencia:\n",
+      "El candidato ha obtenido una puntuación perfecta de 100 gracias a su extensa y relevante experiencia en el campo de la\n",
+      "inteligencia artificial generativa y tecnologías relacionadas. Con más de 17 años de experiencia acumulada, ha trabajado\n",
+      "en puestos clave como Web Publisher y Generative AI Researcher en 'Talking to Chatbots, by Reddgr', donde su enfoque en\n",
+      "la investigación de IA generativa ha sido fundamental. Además, su trayectoria en IBM, donde ocupó roles en soluciones\n",
+      "cognitivas y análisis minorista, ha reforzado su conocimiento en SaaS y su capacidad para gestionar relaciones con\n",
+      "clientes en entornos tecnológicos avanzados. La combinación de estas experiencias, junto con su sólida formación en\n",
+      "consultoría y análisis de datos, lo posiciona como un candidato excepcionalmente calificado para el puesto.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Parámetros de ejecución:\n",
+    "job_text = \"Generative AI engineer\"\n",
+    "cv_sample_path = '../../ejemplos_cvs/DavidGR_cv.txt' # Ruta al fichero de texto con un currículo de ejemplo\n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "# Prompts:\n",
+    "with open('../prompts/ner_pre_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    ner_pre_prompt = f.read()\n",
+    "with open('../prompts/system_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    system_prompt = f.read()\n",
+    "with open('../prompts/user_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    user_prompt = f.read()\n",
+    "# Esquemas JSON:\n",
+    "with open('../json/ner_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    ner_schema = json.load(f)\n",
+    "with open('../json/response_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    response_schema = json.load(f)\n",
+    "\n",
+    "\n",
+    "procesador_cvs_prueba_final = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, \n",
+    "                                           system_prompt, user_prompt, ner_schema, response_schema)\n",
+    "req_experience = 48 # Experiencia requerida en meses\n",
+    "positions_cap=10 # Número máximo de puestos a considerar\n",
+    "dist_threshold_low=0.5 # Distancia límite para considerar un puesto equivalente\n",
+    "dist_threshold_high=0.7 # Distancia límite para considerar un puesto no relevante\n",
+    "dict_respuesta = procesador_cvs_prueba_final.procesar_cv_completo(req_experience=req_experience,\n",
+    "                                                positions_cap=positions_cap,\n",
+    "                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                dist_threshold_high=dist_threshold_high\n",
+    "                                                )"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/04-aplicacion-con-interfaz-de-usuario.ipynb

@@ -0,0 +1,369 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preparación del notebook con OpenAI API key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "API key: sk-proj-****************************************************************************************************************************************************-amA_5sA\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sys\n",
+    "import os\n",
+    "import json\n",
+    "import gradio as gr\n",
+    "sys.path.append('../src')\n",
+    "from procesador_de_cvs_con_llm import ProcesadorCV\n",
+    "from dotenv import load_dotenv\n",
+    "load_dotenv(\"../../../../../../../apis/.env\")\n",
+    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
+    "unmasked_chars = 8\n",
+    "masked_key = api_key[:unmasked_chars] + '*' * (len(api_key) - unmasked_chars*2) + api_key[-unmasked_chars:]\n",
+    "print(f\"API key: {masked_key}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prueba del módulo de procesamiento"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x000001F3282AD0D0>\n",
+      "Respuesta:\n",
+      " {\n",
+      "    \"puntuacion\": 100,\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"Talking to Chatbots, by Reddgr\",\n",
+      "            \"puesto\": \"Web Publisher and Generative AI Researcher\",\n",
+      "            \"duracion\": 218\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Relationship Manager | Cognitive Solutions SaaS\",\n",
+      "            \"duracion\": 43\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"Acoustic\",\n",
+      "            \"puesto\": \"Principal Consultant | Martech SaaS\",\n",
+      "            \"duracion\": 35\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Engagement Manager, in support of Acoustic | B2B SaaS Retail Analytics\",\n",
+      "            \"duracion\": 10\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"IBM\",\n",
+      "            \"puesto\": \"Engagement Manager | B2B SaaS Retail Analytics\",\n",
+      "            \"duracion\": 9\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"MBD Analytics\",\n",
+      "            \"puesto\": \"Business Intelligence Consultant\",\n",
+      "            \"duracion\": 10\n",
+      "        }\n",
+      "    ],\n",
+      "    \"descripcion de la experiencia\": \"El candidato ha demostrado una experiencia excepcional en el campo de la inteligencia artificial generativa, acumulando más de 18 años en roles relevantes. Su posición más destacada como Web Publisher y Generative AI Researcher en 'Talking to Chatbots, by Reddgr' le ha proporcionado una base sólida en investigación y desarrollo de tecnologías de IA. Además, su tiempo en IBM, donde ocupó múltiples roles relacionados con soluciones cognitivas y análisis de datos, ha reforzado su capacidad para manejar proyectos complejos en entornos SaaS. La combinación de estas experiencias, junto con su larga duración en cada puesto, justifica la puntuación máxima de 100, evidenciando su idoneidad para el rol de Generative AI Engineer.\"\n",
+      "}\n",
+      "Descripción de la experiencia:\n",
+      "El candidato ha demostrado una experiencia excepcional en el campo de la inteligencia artificial generativa, acumulando\n",
+      "más de 18 años en roles relevantes. Su posición más destacada como Web Publisher y Generative AI Researcher en 'Talking\n",
+      "to Chatbots, by Reddgr' le ha proporcionado una base sólida en investigación y desarrollo de tecnologías de IA. Además,\n",
+      "su tiempo en IBM, donde ocupó múltiples roles relacionados con soluciones cognitivas y análisis de datos, ha reforzado\n",
+      "su capacidad para manejar proyectos complejos en entornos SaaS. La combinación de estas experiencias, junto con su larga\n",
+      "duración en cada puesto, justifica la puntuación máxima de 100, evidenciando su idoneidad para el rol de Generative AI\n",
+      "Engineer.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Parámetros de ejecución:\n",
+    "job_text = \"Generative AI engineer\"\n",
+    "cv_sample_path = '../../ejemplos_cvs/DavidGR_cv.txt' # Ruta al fichero de texto con un currículo de ejemplo\n",
+    "with open(cv_sample_path, 'r') as file:\n",
+    "    cv_text = file.read()\n",
+    "# Prompts:\n",
+    "with open('../prompts/ner_pre_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    ner_pre_prompt = f.read()\n",
+    "with open('../prompts/system_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    system_prompt = f.read()\n",
+    "with open('../prompts/user_prompt.txt', 'r', encoding='utf-8') as f:\n",
+    "    user_prompt = f.read()\n",
+    "# Esquemas JSON:\n",
+    "with open('../json/ner_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    ner_schema = json.load(f)\n",
+    "with open('../json/response_schema.json', 'r', encoding='utf-8') as f:\n",
+    "    response_schema = json.load(f)\n",
+    "\n",
+    "\n",
+    "procesador_cvs_prueba_final = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, \n",
+    "                                           system_prompt, user_prompt, ner_schema, response_schema)\n",
+    "req_experience = 48 # Experiencia requerida en meses\n",
+    "positions_cap=10 # Número máximo de puestos a considerar\n",
+    "dist_threshold_low=0.5 # Distancia límite para considerar un puesto equivalente\n",
+    "dist_threshold_high=0.7 # Distancia límite para considerar un puesto no relevante\n",
+    "dict_respuesta = procesador_cvs_prueba_final.procesar_cv_completo(req_experience=req_experience,\n",
+    "                                                positions_cap=positions_cap,\n",
+    "                                                dist_threshold_low=dist_threshold_low,\n",
+    "                                                dist_threshold_high=dist_threshold_high\n",
+    "                                                )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prueba de la aplicación Gradio"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Función de carga de la aplicación de \"backend\" para la interfaz Gradio:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def process_cv(job_text, cv_text, req_experience, positions_cap, dist_threshold_low, dist_threshold_high):\n",
+    "    if dist_threshold_low >= dist_threshold_high:\n",
+    "        return {\"error\": \"dist_threshold_low debe ser más bajo que dist_threshold_high.\"}\n",
+    "    \n",
+    "    if not isinstance(cv_text, str) or not cv_text.strip():\n",
+    "        return {\"error\": \"Por favor, introduce el CV o sube un fichero.\"}\n",
+    "\n",
+    "    try:\n",
+    "        procesador = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, \n",
+    "                                  system_prompt, user_prompt, ner_schema, response_schema)\n",
+    "        dict_respuesta = procesador.procesar_cv_completo(\n",
+    "            req_experience=req_experience,\n",
+    "            positions_cap=positions_cap,\n",
+    "            dist_threshold_low=dist_threshold_low,\n",
+    "            dist_threshold_high=dist_threshold_high\n",
+    "        )\n",
+    "        return dict_respuesta\n",
+    "    except Exception as e:\n",
+    "        return {\"error\": f\"Error en el procesamiento: {str(e)}\"}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Interfaz de Gradio:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\david\\anaconda3\\Lib\\site-packages\\gradio\\analytics.py:106: UserWarning: IMPORTANT: You are using gradio version 4.44.0, however version 4.44.1 is available, please upgrade. \n",
+      "--------\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cliente inicializado como <openai.OpenAI object at 0x000001F328980E10>\n",
+      "Respuesta:\n",
+      " {\n",
+      "    \"puntuacion\": 54.75,\n",
+      "    \"experiencia\": [\n",
+      "        {\n",
+      "            \"empresa\": \"bar de tapas\",\n",
+      "            \"puesto\": \"charcutero\",\n",
+      "            \"duracion\": 47\n",
+      "        },\n",
+      "        {\n",
+      "            \"empresa\": \"\",\n",
+      "            \"puesto\": \"camarero\",\n",
+      "            \"duracion\": 2\n",
+      "        }\n",
+      "    ],\n",
+      "    \"descripcion de la experiencia\": \"El candidato cuenta con una experiencia total de 47 meses como charcutero en un bar de tapas, lo que le proporciona habilidades relevantes en atención al cliente y manejo de productos alimenticios. Sin embargo, su experiencia como camarero es limitada, con solo 2 meses, lo que no contribuye significativamente a su perfil para el puesto de cajero de supermercado. La puntuación de 54.75 refleja que, aunque tiene una experiencia considerable en un rol relacionado, no cumple completamente con el requisito de 48 meses de experiencia específica en el área de caja o supermercado.\"\n",
+      "}\n",
+      "Descripción de la experiencia:\n",
+      "El candidato cuenta con una experiencia total de 47 meses como charcutero en un bar de tapas, lo que le proporciona\n",
+      "habilidades relevantes en atención al cliente y manejo de productos alimenticios. Sin embargo, su experiencia como\n",
+      "camarero es limitada, con solo 2 meses, lo que no contribuye significativamente a su perfil para el puesto de cajero de\n",
+      "supermercado. La puntuación de 54.75 refleja que, aunque tiene una experiencia considerable en un rol relacionado, no\n",
+      "cumple completamente con el requisito de 48 meses de experiencia específica en el área de caja o supermercado.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fichero de ejemplo para autocompletar (opción que aparece en la parte de abajo de la interfaz de usuario):\n",
+    "with open('../cv_examples/reddgr_cv.txt', 'r') as file:\n",
+    "    cv_example = file.read()\n",
+    "\n",
+    "default_parameters = [48, 10, 0.5, 0.7] # Parámetros por defecto para el reinicio de la interfaz y los ejemplos predefinidos \n",
+    "\n",
+    "# Código CSS para truncar el texto de ejemplo en la interfaz (bloque \"Examples\" en la parte de abajo):\n",
+    "css = \"\"\"\n",
+    "        table tbody tr {\n",
+    "            height: 2.5em; /* Set a fixed height for the rows */\n",
+    "            overflow: hidden; /* Hide overflow content */\n",
+    "        }\n",
+    "\n",
+    "        table tbody tr td {\n",
+    "            overflow: hidden; /* Ensure content within cells doesn't overflow */\n",
+    "            text-overflow: ellipsis; /* Add ellipsis for overflowing text */\n",
+    "            white-space: nowrap; /* Prevent text from wrapping */\n",
+    "            vertical-align: middle; /* Align text vertically within the fixed height */\n",
+    "        }\n",
+    "        \"\"\"\n",
+    "\n",
+    "# Interfaz Gradio:\n",
+    "with gr.Blocks(css=css) as interface:\n",
+    "    # Inputs\n",
+    "    job_text_input = gr.Textbox(label=\"Título oferta de trabajo\", lines=1, placeholder=\"Introduce el título de la oferta de trabajo\")\n",
+    "    cv_text_input = gr.Textbox(label=\"CV en formato texto\", lines=5, max_lines=5, placeholder=\"Introduce el texto del CV\")\n",
+    "    \n",
+    "    # Opciones avanzadas ocultas en un objeto \"Accordion\"\n",
+    "    with gr.Accordion(\"Opciones avanzadas\", open=False):\n",
+    "        req_experience_input = gr.Number(label=\"Experiencia requerida (en meses)\", value=default_parameters[0], precision=0)\n",
+    "        positions_cap_input = gr.Number(label=\"Número máximo de puestos a extraer\", value=default_parameters[1], precision=0)\n",
+    "        dist_threshold_low_slider = gr.Slider(\n",
+    "            label=\"Umbral mínimo de distancia de embeddings (puesto equivalente)\", \n",
+    "            minimum=0, maximum=1, value=default_parameters[2], step=0.05\n",
+    "        )\n",
+    "        dist_threshold_high_slider = gr.Slider(\n",
+    "            label=\"Umbral máximo de distancia de embeddings (puesto irrelevante)\", \n",
+    "            minimum=0, maximum=1, value=default_parameters[3], step=0.05\n",
+    "        )\n",
+    "    \n",
+    "    submit_button = gr.Button(\"Procesar\")\n",
+    "    clear_button = gr.Button(\"Limpiar\")\n",
+    "    \n",
+    "    output_json = gr.JSON(label=\"Resultado\")\n",
+    "\n",
+    "    # Ejemplos:\n",
+    "    examples = gr.Examples(\n",
+    "        examples=[\n",
+    "            [\"Cajero de supermercado\", \"Trabajo de charcutero desde 2021. Antes trabajé 2 meses de camarero en un bar de tapas.\"] + default_parameters,\n",
+    "            [\"Generative AI Engineer\", cv_example] + default_parameters\n",
+    "        ],\n",
+    "        inputs=[job_text_input, cv_text_input, req_experience_input, positions_cap_input, dist_threshold_low_slider, dist_threshold_high_slider]\n",
+    "    )\n",
+    "\n",
+    "    # Botón \"Procesar\"\n",
+    "    submit_button.click(\n",
+    "        fn=process_cv,\n",
+    "        inputs=[\n",
+    "            job_text_input, \n",
+    "            cv_text_input, \n",
+    "            req_experience_input, \n",
+    "            positions_cap_input, \n",
+    "            dist_threshold_low_slider, \n",
+    "            dist_threshold_high_slider\n",
+    "        ],\n",
+    "        outputs=output_json\n",
+    "    )\n",
+    "\n",
+    "    # Botón \"Limpiar\"\n",
+    "    clear_button.click(\n",
+    "        fn=lambda: (\"\",\"\",*default_parameters),\n",
+    "        inputs=[],\n",
+    "        outputs=[\n",
+    "            job_text_input, \n",
+    "            cv_text_input, \n",
+    "            req_experience_input, \n",
+    "            positions_cap_input, \n",
+    "            dist_threshold_low_slider, \n",
+    "            dist_threshold_high_slider\n",
+    "        ]\n",
+    "    )\n",
+    "\n",
+    "    # Footer\n",
+    "    gr.Markdown(\"\"\"\n",
+    "        <footer>\n",
+    "        <p>Puedes consultar el código completo de esta app y los notebooks explicativos en \n",
+    "        <a href='https://github.com/reddgr' target='_blank'>GitHub</a></p>\n",
+    "        <p>© 2024 <a href='https://talkingtochatbots.com' target='_blank'>talkingtochatbots.com</a></p>\n",
+    "        </footer>\n",
+    "    \"\"\")\n",
+    "\n",
+    "# Lanzar la aplicación:\n",
+    "if __name__ == \"__main__\":\n",
+    "    interface.launch()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/flagged/log.csv

@@ -0,0 +1,2 @@
+Título oferta de trabajo,CV en formato texto,Experiencia requerida (en meses),Número máximo de puestos a extraer,Umbral mínimo de distancia de embeddings (posición equivalente),Umbral máximo de distancia de embeddings (posición irrelevante),output,flag,username,timestamp
+Cajero de supermercado,Trabajo de charcutero desde 2021. Antes trabajé 2 meses de camarero en un bar de tapas.,48,10,0.5,0.7,"{""puntuacion"": 29.72, ""experiencia"": [{""empresa"": ""Desconocida"", ""puesto"": ""Charcutero"", ""duracion"": 47}, {""empresa"": ""Bar de tapas"", ""puesto"": ""Camarero"", ""duracion"": 2}], ""descripcion de la experiencia"": ""La puntuaci\u00f3n de 29.72 refleja una experiencia limitada en relaci\u00f3n con el puesto de Cajero de supermercado. Aunque el candidato tiene una experiencia significativa de aproximadamente 4 a\u00f1os como charcutero, esta no se alinea directamente con las responsabilidades de un cajero. Adem\u00e1s, la experiencia como camarero, aunque es relevante en t\u00e9rminos de atenci\u00f3n al cliente, es de corta duraci\u00f3n y no compensa la falta de experiencia espec\u00edfica en el manejo de caja y transacciones. Por lo tanto, la puntuaci\u00f3n indica que el candidato no cumple con los requisitos necesarios para el puesto.""}",,,2024-12-09 11:41:50.451054