Upload 8 files

cv_examples/reddgr_cv.txt

@@ -0,0 +1,88 @@
+www.linkedin.com/in/davidgonzalezromero (LinkedIn)
+talkingtochatbots.com (Personal)
+Top Skills
+Information and CommunicationsTechnology (ICT)
+Data Science
+Artificial Intelligence (AI)
+Languages
+English (Full Professional)
+French (Limited Working)
+Spanish (Native or Bilingual)
+Certifications
+Watson Analytics - Level 1
+Retail Industry Jumpstart
+Data Science Foundations - Level 1
+Generative AI Imaging: WhatCreative Pros Need to Know
+Prompt Engineering: How to Talk tothe AIs
+Honors-Awards
+Desafío Entorno Pre Mercado 2023
+David González Romero
+ICT Engineer | Business Consultant | Licensed Financial ServicesProfessional | Web Publisher | Profile not suggested by AI | 499connections | reddgr
+Greater Madrid Metropolitan Area
+Summary
+I am an Information and Communications Technology Engineer andBusiness Consultant with over 15 years of experience in enterprisesoftware solutions, consulting, business analytics, and data science,across multiple countries and cross-functional teams.Over the last two decades, I have enjoyed the privilege of travelingaround the world, teaming up with outstanding professionals,leading teams, developing business opportunities, and buildingand managing longstanding client relationships. Throughout myconsulting and client relationship management career, I haveprimarily served clients in the retail industry, financial services,telecommunications, and the public sector, developing skills andknowledge across diverse domains such as marketing, finance, riskmanagement, software engineering, and data science.In academia, I completed MSc studies in telecommunications,electrical, and computer engineering, with research in ubiquitouscomputing, the Internet of Things, and computer security. Currently,I'm pursuing a master's degree in Artificial Intelligence Applied toFinancial Markets, and managing Talking to Chatbots, a websitededicated to generative AI projects, popular culture, and education,available at https://talkingtochatbots.com.
+Experience
+Talking to Chatbots, by Reddgr
+Web Publisher and Generative AI Researcher
+October 2006 - Present (18 years 3 months)
+Spain
+Developed and managed personal projects on the Internet since 2006.Currently managing the internet domains https://talkingtochatbots.com(website) and https://reddgr.com (search engine and social media keyword:
+Page 1 of 6
+“reddgr” stands for “David González Romero network”). Talking to Chatbotsis a knowledge hub that compiles LLM prompts and curated conversations,serving as an entertainment and educational platform for AI hobbyists,learners, and professionals.Since 2023, active developer and contributor in open-source and proprietarygenerative AI platforms and communities (reddgr.com/gpts huggingface.com/reddgr)
+Acoustic
+Principal Consultant | Martech SaaS
+June 2020 - May 2023 (3 years)
+Spain
+Advised retail companies on implementing profitable, competitive pricingstrategies and promotions backed by DemandTec software as a service(SaaS) solutions and data science. Primary focus on developing and leadingsuccessful client relationships. Dedicated to continuously improving Acousticproducts and ensuring that clients and prospects receive excellent servicefrom Acoustic’s team and business partners. This involved delivering andmanaging: consultative selling, employee recruitment, training and mentoring,solution implementations, SaaS managed services (data integration andmodeling), technical support, customer relationship management (CRM), andanalytics consulting services.Companies served by the team of consultants and account managers I ledinclude: leading Spanish retailer; Italian supermarket cooperative; multinationalretail company operating in the Middle East, Eastern Europe and Africa;leading Italian retail group; Swedish grocery retailer; online retailer operating inthe UK and Ireland; British retailer with multinational presence; Finland-basedmultinational retail company; leading Norwegian retailer; retail cooperativein the Nordic countries; major multinational retail group operating in SouthAmerica.Participated in or led pre-sales activities (RFI, RFP, POC, RFQ) for variousnational and multinational retailers based in Southern Europe, Central Europe,Nordics, the Middle East and Australia.
+IBM
+7 years 3 months
+Engagement Manager, in support of Acoustic | B2B SaaS Retail Analytics
+Page 2 of 6
+July 2019 - May 2020 (11 months)
+Madrid, Community of Madrid, Spain
+Employed by IBM exclusively in support of Acoustic, new company founded in2019 by a team of IBM Watson Marketing & Commerce software specialists,led by former IBM executives and funded by private equity. Specialist inAcoustic Pricing and Promotion solutions (DemandTec), acting as AcousticSoftware Services team leader in Spain, and as software delivery EngagementManager and Subject Matter Expert for pre-sales and services projectsworldwide. Acoustic clients I worked with include: leading Spanish retailer, supermarketcooperative based in central and southern Italy, multinational retail companyoperating in Middle East, Eastern Europe and Africa, leading Italian retailgroup.
+Engagement Manager | B2B SaaS Retail Analytics
+September 2018 - June 2019 (10 months)
+Madrid, Community of Madrid, Spain
+Managing services projects and SaaS engagements for IBM WatsonCommerce solutions. As cognitive solutions specialist and SME in retail pricingand business analytics, I helped IBM clients succeed by coordinating allcomponents of the IBM Omni-Channel Pricing (DemandTec) cloud-basedsolution, including: solution design and PoC's, solution implementation anddelivery, data science services, data integration services, SaaS operations,technical support, product management, benefits assessments, and analyticalconsulting services.IBM clients I worked with as Engagement Manager or SME include: leadingSpanish retailer, multinational retail company operating in Middle East, EasternEurope and Africa, leading Italian retail group, Italian supermarket cooperative.
+Relationship Manager | Cognitive Solutions SaaS
+January 2015 - August 2018 (3 years 8 months)
+Madrid, Community of Madrid, Spain
+Specialist in the IBM Omni-channel Merchandising (DemandTec) solutionfor the retail industry, including Price Optimization, Promotion Planning andDynamic Pricing software.Managed the day to day relationship with assigned clients (€ 2 million ARR),prospecting and coordinating the delivery of SaaS platform enablementservices (data integration and data science), technical support, project
+Page 3 of 6
+management, and end-user enablement. Collaborated in other internationalprojects as DemandTec and pricing SME, delivering training and projectguidance to client end-users and business partners.IBM clients I worked with include: multiple Merchandising divisions of leadingSpanish retailer, multinational supermarket chain based in Spain, supermarketco-operative based in Denmark, multinational retail company operating inMiddle East, Eastern Europe and Africa, Russian supermarket chain, Finland-based retail company, British consumer co-operative.
+Business Analyst | B2B SaaS Retail Analytics
+March 2013 - December 2014 (1 year 10 months)
+Madrid, Community of Madrid, Spain
+Delivery of IBM Enterprise Marketing Management implementation projects,including DemandTec Price Optimization, Markdown Optimization andAssortment Optimization SaaS solutions. Delivered business and technicalguidance to pricing managers, category managers, buyers and businessconsultants in solution architecture, problem management resolution andchange management. Specialist in performing data analysis on the datascience, optimization and business analytics tools and services included in thesolution.IBM clients I worked with include: leading Spanish retailer, multinationalfashion retailer based in Spain, US-based sports retailer, supermarket co-operative based in Denmark.
+KPMG España
+Senior Consultant | Financial Risk Management
+December 2010 - March 2013 (2 years 4 months)
+Madrid, Community of Madrid, Spain
+Senior Consultant in Financial Risk Management. Main projects:• Corporate and Investment Banking financial reporting: data mining andanalytics for Finance and Business Performance & Analytics department atleading multinational banking and financial services company. Developed andmaintained financial reports and insights for CFO, senior management andfront office.• Retail and Business Banking credit risk modeling: led user acceptancetesting and test case development for credit risk models and EBA-compliantreporting (COREP) of capital requirements. Led UAT development team and
+Page 4 of 6
+acted as a link between IT teams and Risk department. Supported credit riskmodeling team on early implementation of internal ratings-based (IRB) creditrisk models in compliance with Basel Framework on banking supervision.
+MBD Analytics
+Business Intelligence Consultant
+February 2010 - December 2010 (11 months)
+Alcobendas, Community of Madrid, Spain
+Marketing Business Intelligence consulting services. Client-facing consultantfor Competitive Intelligence department at a multinational telecommunicationscompany. Responsible for the development of custom BI reporting solutionsand presenting monthly business reports. The reports included insights,analysis and forecasting of KPIs measuring customer activity and value inconsumer and enterprise telecommunication services.
+Grupo Eneas
+Cost Analyst
+November 2009 - December 2009 (2 months)
+Madrid, Community of Madrid, Spain
+Telecommunications cost optimization project for a regional governmentagency of Spain. Gathered and analyzed invoice and contract data in supportof a Request for Quotation (RFQ) to a selection of telecommunication serviceproviders.
+Deloitte España
+IT Strategy Consultant
+September 2008 - January 2009 (5 months)
+Madrid, Community of Madrid, Spain
+Management consulting intern, collaborating on IT management projects forinsurance, banking and public sector companies and institutions based inSpain. Collaborated on research, documentation, elaboration of proposals andtechnical support for IT management consulting projects, including: IT strategicplanning and market research, IT service management, IT integration, and ITcost optimization.
+Education
+Illinois Institute of Technology
+Research Scholar, Electrical & Computer Engineering · (2009 - 2009)
+Page 5 of 6
+Universidad Politécnica de Madrid
+Master of Science (MSc), Telecommunications Engineer · (2003 - 2009)
+Instituto BME
+Master's degree, Artificial Intelligence Applied to Financial Markets(MIAX) · (October 2023 - May 2025)
+Page 6 of 6

json/ner_schema.json

@@ -0,0 +1,21 @@
+{
+    "type": "object",
+    "properties": {
+        "experiencia": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "empresa": {"type": "string"},
+                    "puesto": {"type": "string"},
+                    "periodo": {
+                        "type": "string",
+                        "description": "Formato 'YYYYMM-YYYYMM' o simplemente 'YYYYMM' si no aparece fecha de fin."
+                    }
+                },
+                "required": ["empresa", "puesto", "periodo"]
+            }
+        }
+    },
+    "required": ["experiencia"]
+}

json/response_schema.json

@@ -0,0 +1,38 @@
+{
+    "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"
+    ]
+}

prompts/ner_pre_prompt.txt

@@ -0,0 +1 @@
+Eres un procesador de currículos vitae que extrae títulos de puestos de trabajo, nombres de la empresa, y períodos de los mismos. Usa formato json en la salida con las claves "empresa", "puesto" y "periodo". Para el período, contempla cualquier formato de fecha o rango de fechas incluido en el texto. Un ejemplo de formato de fecha en la entrada es "Octubre 2023 / Marzo 2024". El contenido para la clave "período" debe ser un string con dos elementos en formato YYYYMM separados por un guion, por ejemplo "202310-202403", o uno en caso de no identificarse fecha de fin.

prompts/system_prompt.txt

@@ -0,0 +1 @@
+Eres un procesador de currículos vitae que recibe una oferta de trabajo un currículum vitae filtrado la experiencia relevante previa, una puntuación precalculada para el currículo entre 0 y 100, y un parámetro de experiencia requerida en meses. La puntuación se ha calculado mediante un algoritmo que usa distancias de embeddings entre cada uno de los 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 requerida. Devuelves un objeto con el esquema predefinido,incluyendo exactamente la misma puntuación proporcionada, el listado de experiencia proporcionado y además devuelves un breve texto explicativo sobre la experiencia del candidato y  por qué ha obtenido la puntuación dada. Es importante que el texto explicativo sea coherente con la puntuación. Por ejemplo, si la puntuación es mayor que 80, el texto explicativo debe hacer énfasis en las experiencias pasadas y la duración de las mismas que han llevado a esa puntuación. Cuando menciones alguna duración de una experiencia superior a 12 meses, incluye en el texto sólo el aproximado en años, dado que los datos exactos están en el listado de experiencia adjunto.

prompts/user_prompt.txt

@@ -0,0 +1 @@
+El título de la oferta de trabajo es: {job}.La experiencia requerida en meses es: {req_experience}.La puntuacion es {puntuacion}, La experiencia relevante es: {exp}. Explica por qué se ha obtenido la puntuación

src/procesador_de_cvs_con_llm.py

@@ -0,0 +1,284 @@
+
+import os
+import pandas as pd
+import json
+import textwrap
+from scipy import spatial
+from datetime import datetime
+from openai import OpenAI
+
+class ProcesadorCV:
+
+    def __init__(self, api_key, cv_text, job_text, ner_pre_prompt, system_prompt, user_prompt, ner_schema, response_schema,
+                inference_model="gpt-4o-mini", embeddings_model="text-embedding-3-small"):
+        """
+        Inicializa una instancia de la clase con los parámetros proporcionados.
+
+        Args:
+            api_key (str): La clave de API para autenticar con el cliente OpenAI.
+            cv_text (str): contenido del CV en formato de texto.
+            job_text (str): título de la oferta de trabajo a evaluar.
+            ner_pre_prompt (str): instrucción de "reconocimiento de entidades nombradas" (NER) para el modelo en lenguaje natural.
+            system_prompt (str): instrucción en lenguaje natural para la salida estructurada final.
+            user_prompt (str): instrucción con los parámetros y datos calculados en el preprocesamiento.
+            ner_schema (dict): esquema para la llamada con "structured outputs" al modelo de OpenAI para NER.
+            response_schema (dict): esquema para la respuesta final de la aplicación.
+            inference_model (str, opcional): El modelo de inferencia a utilizar. Por defecto es "gpt-4o-mini".
+            embeddings_model (str, opcional): El modelo de embeddings a utilizar. Por defecto es "text-embedding-3-small".
+
+        Atributos:
+            inference_model (str): Almacena el modelo de inferencia seleccionado.
+            embeddings_model (str): Almacena el modelo de embeddings seleccionado.
+            client (OpenAI): Instancia del cliente OpenAI inicializada con la clave de API proporcionada.
+            cv (str): Almacena el texto del currículum vitae proporcionado.
+
+        """
+        self.inference_model = inference_model
+        self.embeddings_model = embeddings_model
+        self.ner_pre_prompt = ner_pre_prompt
+        self.user_prompt = user_prompt
+        self.system_prompt = system_prompt
+        self.ner_schema = ner_schema
+        self.response_schema = response_schema
+        self.client = OpenAI(api_key=api_key)
+        self.cv = cv_text
+        self.job_text = job_text
+        print("Cliente inicializado como",self.client)
+
+    def extraer_datos_cv(self, temperature=0.5):
+        """
+        Extrae datos estructurados de un CV con OpenAI API.
+        Args:
+            pre_prompt (str): instrucción para el modelo en lenguaje natural.
+            schema (dict): esquema de los parámetros que se espera extraer del CV.
+            temperature (float, optional): valor de temperatura para el modelo de lenguaje. Por defecto es 0.5.
+        Returns:
+            pd.DataFrame: DataFrame con los datos estructurados extraídos del CV.
+        Raises:
+            ValueError: si no se pueden extraer datos estructurados del CV.
+        """
+        response = self.client.chat.completions.create(
+            model=self.inference_model,
+            temperature=temperature,
+            messages=[
+                {"role": "system", "content": self.ner_pre_prompt},
+                {"role": "user", "content": self.cv}
+            ],
+            functions=[
+                {
+                    "name": "extraer_datos_cv",
+                    "description": "Extrae tabla con títulos de puesto de trabajo, nombres de empresa y períodos de un CV.",
+                    "parameters": self.ner_schema
+                }
+            ],
+            function_call="auto"
+        )
+
+        if response.choices[0].message.function_call:
+            function_call = response.choices[0].message.function_call
+            structured_output = json.loads(function_call.arguments)
+            if structured_output.get("experiencia"):
+                df_cv = pd.DataFrame(structured_output["experiencia"]) 
+                return df_cv
+            else:
+                raise ValueError(f"No se han podido extraer datos estructurados: {response.choices[0].message.content}")
+        else:
+            raise ValueError(f"No se han podido extraer datos estructurados: {response.choices[0].message.content}")
+        
+
+    def procesar_periodos(self, df):    
+        """
+        Procesa los períodos en un DataFrame y añade columnas con las fechas de inicio, fin y duración en meses. 
+        Si no hay fecha de fin, se considera la fecha actual.
+        Args:
+            df (pandas.DataFrame): DataFrame que contiene una columna 'periodo' con períodos en formato 'YYYYMM-YYYYMM' o 'YYYYMM'.
+        Returns:
+            pandas.DataFrame: DataFrame con columnas adicionales 'fec_inicio', 'fec_final' y 'duracion'.
+                - 'fec_inicio' (datetime.date): Fecha de inicio del período.
+                - 'fec_final' (datetime.date): Fecha de fin del período.
+                - 'duracion' (int): Duración del período en meses.
+        """
+        # Función lambda para procesar el período
+        def split_periodo(periodo):
+            dates = periodo.split('-')
+            start_date = datetime.strptime(dates[0], "%Y%m")
+            if len(dates) > 1:
+                end_date = datetime.strptime(dates[1], "%Y%m")
+            else:
+                end_date = datetime.now()
+            return start_date, end_date
+
+        df[['fec_inicio', 'fec_final']] = df['periodo'].apply(lambda x: pd.Series(split_periodo(x)))
+
+        # 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)
+        df['fec_inicio'] = df['fec_inicio'].dt.date
+        df['fec_final'] = df['fec_final'].dt.date
+
+        # Añadimos una columna con la duración en meses
+        df['duracion'] = df.apply(
+            lambda row: (row['fec_final'].year - row['fec_inicio'].year) * 12 + 
+                        row['fec_final'].month - row['fec_inicio'].month, 
+            axis=1
+        )
+
+        return df
+
+
+    def calcular_embeddings(self, df, column='puesto', model_name='text-embedding-3-small'):
+        """
+        Calcula los embeddings de una columna de un dataframe con OpenAI API.
+        Args:
+            cv_df (pandas.DataFrame): DataFrame con los datos de los CV.
+            column (str, optional): Nombre de la columna que contiene los datos a convertir en embeddings. Por defecto es 'puesto'.
+            model_name (str, optional): Nombre del modelo de embeddings. Por defecto es 'text-embedding-3-small'.
+        """
+        df['embeddings'] = df[column].apply(
+            lambda puesto: self.client.embeddings.create(
+                input=puesto, 
+                model=model_name
+            ).data[0].embedding
+        )
+        return df
+
+
+    def calcular_distancias(self, df, column='embeddings', model_name='text-embedding-3-small'):
+        """
+        Calcula la distancia coseno entre los embeddings del texto y los incluidos en una columna del dataframe.
+        Params:
+        df (pandas.DataFrame): DataFrame que contiene los embeddings.
+        column (str, optional): nombre de la columna del DataFrame que contiene los embeddings. Por defecto, 'embeddings'.
+        model_name (str, optional): modelo de embeddings de la API de OpenAI. Por defecto "text-embedding-3-small".
+        Returns:
+        pandas.DataFrame: DataFrame ordenado de menor a mayor distancia, con las distancias en una nueva columna.
+        """
+        response = self.client.embeddings.create(
+            input=self.job_text,
+            model=model_name
+        )
+        emb_compare = response.data[0].embedding
+
+        df['distancia'] = df[column].apply(lambda emb: spatial.distance.cosine(emb, emb_compare))
+        df.drop(columns=[column], inplace=True)
+        df.sort_values(by='distancia', ascending=True, inplace=True)
+        return df
+
+
+    def calcular_puntuacion(self, df, req_experience, positions_cap=4, dist_threshold_low=0.6, dist_threshold_high=0.7):
+        """
+        Calcula la puntuación de un CV a partir de su tabla de distancias (con respecto a un puesto dado) y duraciones. 
+
+        Params:
+        df (pandas.DataFrame): datos de un CV incluyendo diferentes experiencias incluyendo duracies y distancia previamente calculadas sobre los embeddings de un puesto de trabajo
+        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)
+        positions_cap (int, optional): Maximum number of positions to consider for scoring. Defaults to 4.
+        dist_threshold_low (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV se considera "equivalente" al de la oferta.
+        max_dist_threshold (float, optional): Distancia entre embeddings a partir de la cual el puesto del CV no puntúa.
+        
+        Returns:
+        pandas.DataFrame: DataFrame original añadiendo una columna con las puntuaciones individuales contribuidas por cada puesto.
+        float: Puntuación total entre 0 y 100.
+        """
+        # A efectos de puntuación, computamos para cada puesto como máximo el número total de meses de experiencia requeridos
+        df['duration_capped'] = df['duracion'].apply(lambda x: min(x, req_experience))
+        # Normalizamos la distancia entre 0 y 1, siendo 0 la distancia mínima y 1 la máxima
+        df['adjusted_distance'] = df['distancia'].apply(
+            lambda x: 0 if x <= dist_threshold_low else (
+                1 if x >= dist_threshold_high else (x - dist_threshold_low) / (dist_threshold_high - dist_threshold_low)
+            )
+        )
+        # Cada puesto puntúa en base a su duración y a la inversa de la distancia (a menor distancia, mayor puntuación)
+        df['position_score'] = round(((1 - df['adjusted_distance']) * (df['duration_capped']/req_experience) * 100), 2)
+        # Descartamos puestos con distancia superior al umbral definido (asignamos puntuación 0), y ordenamos por puntuación
+        df.loc[df['distancia'] >= dist_threshold_high, 'position_score'] = 0
+        df = df.sort_values(by='position_score', ascending=False)
+        # Nos quedamos con los puestos con mayor puntuación (positions_cap)
+        df.iloc[positions_cap:, df.columns.get_loc('position_score')] = 0
+        # Totalizamos (no debería superar 100 nunca, pero ponemos un límite para asegurar) y redondeamos a dos decimales
+        total_score = round(min(df['position_score'].sum(), 100), 2)
+        return df, total_score
+    
+    def filtra_experiencia_relevante(self, df):
+        """
+        Filtra las experiencias relevantes del dataframe y las devuelve en formato diccionario.
+        Args:
+            df (pandas.DataFrame): DataFrame con la información completa de experiencia.
+        Returns:
+            dict: Diccionario con las experiencias relevantes.
+        """
+        df_experiencia =  df[df['position_score'] > 0].copy()
+        df_experiencia.drop(columns=['periodo', 'fec_inicio', 'fec_final', 
+                                     'distancia', 'duration_capped', 'adjusted_distance'], inplace=True)
+        experiencia_dict = df_experiencia.to_dict(orient='list')
+        return experiencia_dict
+    
+    def llamada_final(self, req_experience, puntuacion, dict_experiencia):
+        """
+        Realiza la llamada final al modelo de lenguaje para generar la respuesta final.
+        Args:
+        req_experience (int): Experiencia requerida en meses para el puesto de trabajo.
+        puntuacion (float): Puntuación total del CV.
+        dict_experiencia (dict): Diccionario con las experiencias relevantes.
+        Returns:
+        dict: Diccionario con la respuesta final.
+        """
+        messages = [
+            {
+                "role": "system",
+                "content": self.system_prompt
+            },
+            {
+                "role": "user",
+                "content": self.user_prompt.format(job=self.job_text, req_experience=req_experience,puntuacion=puntuacion, exp=dict_experiencia)
+            }
+        ]
+
+        functions = [
+            {
+                "name": "respuesta_formateada",
+                "description": "Devuelve el objeto con puntuacion, experiencia y descripcion de la experiencia",
+                "parameters": self.response_schema
+            }
+        ]
+
+        response = self.client.chat.completions.create(
+            model=self.inference_model,
+            temperature=0.5,
+            messages=messages,
+            functions=functions,
+            function_call={"name": "respuesta_formateada"}
+        )
+
+        if response.choices[0].message.function_call:
+            function_call = response.choices[0].message.function_call
+            structured_output = json.loads(function_call.arguments)
+            print("Respuesta:\n", json.dumps(structured_output, indent=4, ensure_ascii=False))
+            wrapped_description = textwrap.fill(structured_output['descripcion de la experiencia'], width=120)
+            print(f"Descripción de la experiencia:\n{wrapped_description}")
+            return structured_output
+        else:
+            raise ValueError(f"Error. No se ha podido generar respuesta:\n {response.choices[0].message.content}")
+    
+    def procesar_cv_completo(self, req_experience, positions_cap, dist_threshold_low, dist_threshold_high):
+        """
+        Procesa un CV y calcula la puntuación final.
+        Args:
+            req_experience (int, optional): Experiencia requerida en meses para el puesto de trabajo.
+            positions_cap (int, optional): Número máximo de puestos a considerar para la puntuación.
+            dist_threshold_low (float, optional): Distancia límite para considerar un puesto equivalente.
+            dist_threshold_high (float, optional): Distancia límite para considerar un puesto no relevante.
+        Returns:
+            pd.DataFrame: DataFrame con las puntuaciones individuales contribuidas por cada puesto.
+            float: Puntuación total entre 0 y 100.
+        """
+        df_datos_estructurados_cv = self.extraer_datos_cv()
+        df_datos_estructurados_cv = self.procesar_periodos(df_datos_estructurados_cv)
+        df_con_embeddings = self.calcular_embeddings(df_datos_estructurados_cv)
+        df_con_distancias = self.calcular_distancias(df_con_embeddings)
+        df_puntuaciones, puntuacion = self.calcular_puntuacion(df_con_distancias,
+                                                                req_experience=req_experience,
+                                                                positions_cap=positions_cap,
+                                                                dist_threshold_low=dist_threshold_low,
+                                                                dist_threshold_high=dist_threshold_high)
+        dict_experiencia = self.filtra_experiencia_relevante(df_puntuaciones)
+        dict_respuesta = self.llamada_final(req_experience, puntuacion, dict_experiencia)
+        return dict_respuesta