English version

app.py

@@ -0,0 +1,161 @@
+import sys
+import os
+import json
+import gradio as gr
+sys.path.append('src')
+from procesador_de_cvs_con_llm import ProcesadorCV
+
+use_dotenv = False
+if use_dotenv:
+    from dotenv import load_dotenv
+    load_dotenv("../../../../../../../apis/.env")
+    api_key = os.getenv("OPENAI_API_KEY")
+
+else:
+    api_key = os.getenv("OPENAI_API_KEY")
+
+unmasked_chars = 8
+masked_key = api_key[:unmasked_chars] + '*' * (len(api_key) - unmasked_chars*2) + api_key[-unmasked_chars:]
+print(f"API key: {masked_key}")
+
+def process_cv(job_text, cv_text, req_experience, req_experience_unit, positions_cap, dist_threshold_low, dist_threshold_high):
+    if dist_threshold_low >= dist_threshold_high:
+        return {"error": "dist_threshold_low must be lower than dist_threshold_high."}
+    
+    if not isinstance(cv_text, str) or not cv_text.strip():
+        return {"error": "Please provide the CV or upload a file."}
+    
+    # Convertir la experiencia requerida a meses si se introduce en años
+    if req_experience_unit == "years":
+        req_experience = req_experience * 12
+
+    try:
+        procesador = ProcesadorCV(api_key, cv_text, job_text, ner_pre_prompt, 
+                                  system_prompt, user_prompt, ner_schema, response_schema)
+        dict_respuesta = procesador.procesar_cv_completo(
+            req_experience=req_experience,
+            positions_cap=positions_cap,
+            dist_threshold_low=dist_threshold_low,
+            dist_threshold_high=dist_threshold_high
+        )
+        return dict_respuesta
+    except Exception as e:
+        return {"error": f"Processing error: {str(e)}"}
+
+# Parámetros de ejecución:
+job_text = "Generative AI engineer"
+cv_sample_path = 'cv_examples/reddgr_cv.txt' # Ruta al fichero de texto con un currículo de ejemplo
+with open(cv_sample_path, 'r', encoding='utf-8') as file:
+    cv_text = file.read()
+# Prompts:
+with open('prompts/ner_pre_prompt.txt', 'r', encoding='utf-8') as f:
+    ner_pre_prompt = f.read()
+with open('prompts/system_prompt.txt', 'r', encoding='utf-8') as f:
+    system_prompt = f.read()
+with open('prompts/user_prompt.txt', 'r', encoding='utf-8') as f:
+    user_prompt = f.read()
+# Esquemas JSON:
+with open('json/ner_schema.json', 'r', encoding='utf-8') as f:
+    ner_schema = json.load(f)
+with open('json/response_schema.json', 'r', encoding='utf-8') as f:
+    response_schema = json.load(f)
+
+# Fichero de ejemplo para autocompletar (opción que aparece en la parte de abajo de la interfaz de usuario):
+with open('cv_examples/reddgr_cv.txt', 'r', encoding='utf-8') as file:
+    cv_example = file.read()
+
+default_parameters = [4, "years", 10, 0.5, 0.7] # Parámetros por defecto para el reinicio de la interfaz y los ejemplos predefinidos 
+
+# Código CSS para truncar el texto de ejemplo en la interfaz (bloque "Examples" en la parte de abajo):
+css = """
+        table tbody tr {
+            height: 2.5em; /* Set a fixed height for the rows */
+            overflow: hidden; /* Hide overflow content */
+        }
+
+        table tbody tr td {
+            overflow: hidden; /* Ensure content within cells doesn't overflow */
+            text-overflow: ellipsis; /* Add ellipsis for overflowing text */
+            white-space: nowrap; /* Prevent text from wrapping */
+            vertical-align: middle; /* Align text vertically within the fixed height */
+        }
+        """
+
+# Interfaz Gradio:
+with gr.Blocks(css=css) as interface:
+    # Inputs
+    job_text_input = gr.Textbox(label="Vacancy Title", lines=1, placeholder="Enter the vacancy title")
+    gr.Markdown("Required Experience")
+    with gr.Row():
+        req_experience_input = gr.Number(label="Required Experience", value=default_parameters[0], precision=0, elem_id="req_exp", show_label=False)
+        req_experience_unit = gr.Dropdown(label="Period", choices=["months", "years"], value=default_parameters[1], elem_id="req_exp_unit", show_label=False)
+    cv_text_input = gr.Textbox(label="CV in Text Format", lines=5, max_lines=5, placeholder="Enter the CV text")
+    
+    # Opciones avanzadas ocultas en un objeto "Accordion"
+    with gr.Accordion("Advanced options", open=False):
+        positions_cap_input = gr.Number(label="Maximum number of positions to extract", value=default_parameters[2], precision=0)
+        dist_threshold_low_slider = gr.Slider(
+            label="Minimum embedding distance threshold (equivalent position)", 
+            minimum=0, maximum=1, value=default_parameters[3], step=0.05
+        )
+        dist_threshold_high_slider = gr.Slider(
+            label="Maximum embedding distance threshold (irrelevant position)", 
+            minimum=0, maximum=1, value=default_parameters[4], step=0.05
+        )
+    
+    submit_button = gr.Button("Process")
+    clear_button = gr.Button("Clear")
+    
+    output_json = gr.JSON(label="Result")
+
+    # Ejemplos:
+    examples = gr.Examples(
+        examples=[
+            ["Supermarket cashier", "Deli worker since 2021. Previously worked 2 months as a waiter in a tapas bar."] + default_parameters,
+            ["Generative AI Engineer", cv_example] + default_parameters
+        ],
+        inputs=[job_text_input, cv_text_input, req_experience_input, req_experience_unit, positions_cap_input, dist_threshold_low_slider, dist_threshold_high_slider]
+    )
+
+    # Botón "Procesar"
+    submit_button.click(
+        fn=process_cv,
+        inputs=[
+            job_text_input, 
+            cv_text_input, 
+            req_experience_input, 
+            req_experience_unit,
+            positions_cap_input, 
+            dist_threshold_low_slider, 
+            dist_threshold_high_slider
+        ],
+        outputs=output_json
+    )
+
+    # Botón "Limpiar"
+    clear_button.click(
+        fn=lambda: ("","",*default_parameters),
+        inputs=[],
+        outputs=[
+            job_text_input, 
+            cv_text_input, 
+            req_experience_input, 
+            req_experience_unit,
+            positions_cap_input, 
+            dist_threshold_low_slider, 
+            dist_threshold_high_slider
+        ]
+    )
+
+    # Footer
+    gr.Markdown("""
+        <footer>
+        <p>You can view the complete code for this app and the explanatory notebooks on 
+        <a href='https://github.com/reddgr/procesador-de-curriculos-cv' target='_blank'>GitHub</a></p>
+        <p>© 2024 <a href='https://talkingtochatbots.com' target='_blank'>talkingtochatbots.com</a></p>
+        </footer>
+    """)
+
+# Lanzar la aplicación:
+if __name__ == "__main__":
+    interface.launch()

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": {
+        "experience": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "company": {"type": "string"},
+                    "role": {"type": "string"},
+                    "period": {
+                        "type": "string",
+                        "description": "'YYYYMM-YYYYMM' format or simply 'YYYYMM' if no end date is given."
+                    }
+                },
+                "required": ["company", "role", "period"]
+            }
+        }
+    },
+    "required": ["experience"]
+}

json/response_schema.json

@@ -0,0 +1,38 @@
+{
+    "type": "object",
+    "properties": {
+        "score": {
+            "type": "number"
+        },
+        "relevant experience": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "company": {
+                        "type": "string"
+                    },
+                    "role": {
+                        "type": "string"
+                    },
+                    "duration": {
+                        "type": "integer"
+                    }
+                },
+                "required": [
+                    "company",
+                    "role",
+                    "duration"
+                ]
+            }
+        },
+        "experience summary": {
+            "type": "string"
+        }
+    },
+    "required": [
+        "score",
+        "relevant experience",
+        "experience summary"
+    ]
+}

pkl/df_ejemplos_con_distancia.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:41724c6196d4862a3b08d417024549c4f4f644fdc031d7eda324dc715fa14824
+size 1623

pkl/df_experiencia.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:726aabfa90eddf805b685ab14231dc18fbdabf1033d7c4649dddcaa0f2936454
+size 1501

prompts/ner_pre_prompt.txt

@@ -0,0 +1 @@
+You are a resume processor that extracts job titles, company names, and their corresponding periods. Use JSON format in the output with the keys "empresa", "puesto", and "periodo". For the period, consider any date format or range of dates included in the text. An example of a date format in the input is "October 2023 / March 2024". The value for the "periodo" key should be a string with two elements in YYYYMM format separated by a hyphen, for example "202310-202403", or only one element if no end date is identified.

prompts/system_prompt.txt

@@ -0,0 +1 @@
+You are a curriculum vitae processor that receives a job offer, a filtered curriculum vitae, relevant previous experience, a precalculated score for the curriculum between 0 and 100, and a required experience parameter in months. The score has been calculated using an algorithm that utilizes embedding distances between each role and the job offer's definition, as well as the duration of each role and its relationship with the required experience parameter. It returns an object with a predefined schema, including exactly the provided score, the given list of experiences, and additionally a brief explanatory text about the candidate's experience and why they have obtained the given score. It is important that the explanatory text is coherent with the score. For example, if the score is greater than 80, the explanatory text should emphasize the candidate's past experiences and the duration of those experiences that have led to that score. When mentioning any experience duration exceeding 12 months, include in the text only an approximate conversion to years, as the exact data is provided in the attached experience list.

prompts/user_prompt.txt

@@ -0,0 +1 @@
+The vacancy title is: {job}. The required experience in months is {req_experience}. The score is {puntuacion}. The relevant experience is: {exp}. Explain why the score was obtained.

src/procesador_de_cvs_con_llm.py

@@ -0,0 +1,292 @@
+
+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"):
+        """
+        Initializes an instance of the class with the provided parameters.
+
+        Args:
+            api_key (str): The API key to authenticate with the OpenAI client.
+            cv_text (str): CV content in text format.
+            job_text (str): title of the job offer to evaluate.
+            ner_pre_prompt (str): "Named Entity Recognition" (NER) instruction for the natural language model.
+            system_prompt (str): natural language instruction for the final structured output.
+            user_prompt (str): instruction with parameters and data calculated in preprocessing.
+            ner_schema (dict): schema for the "structured outputs" call to the OpenAI model for NER.
+            response_schema (dict): schema for the final application response.
+            inference_model (str, optional): The inference model to use. Default is "gpt-4o-mini".
+            embeddings_model (str, optional): The embeddings model to use. Default is "text-embedding-3-small".
+
+        Attributes:
+            inference_model (str): Stores the selected inference model.
+            embeddings_model (str): Stores the selected embeddings model.
+            client (OpenAI): Instance of the OpenAI client initialized with the provided API key.
+            cv (str): Stores the provided curriculum vitae text.
+        """
+        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):
+        """
+        Extracts structured data from a CV using OpenAI API.
+        Args:
+            temperature (float, optional): temperature value for the language model. Default is 0.5.
+        Returns:
+            pd.DataFrame: DataFrame with structured data extracted from the CV.
+        Raises:
+            ValueError: if structured data cannot be extracted from the 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": "Extracts table with job titles, company names and periods from a 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("experience"):
+                df_cv = pd.DataFrame(structured_output["experience"]) 
+                return df_cv
+            else:
+                raise ValueError(f"Unable to extract structured data: {response.choices[0].message.content}")
+        else:
+            raise ValueError(f"Unable to extract structured data: {response.choices[0].message.content}")
+        
+
+    def procesar_periodos(self, df):    
+        """
+        Process periods in a DataFrame and adds columns with start dates, end dates, and duration in months.
+        If there is no end date, the current date is considered.
+            df (pandas.DataFrame): DataFrame containing a 'period' column with periods in 'YYYYMM-YYYYMM' or 'YYYYMM' format.
+            pandas.DataFrame: DataFrame with additional columns 'fec_inicio', 'fec_final', and 'duracion'.
+                - 'fec_inicio' (datetime.date): Start date of the period.
+                - 'fec_final' (datetime.date): End date of the period.
+                - 'duracion' (int): Duration of the period in months.
+        """
+        # Función lambda para procesar el período
+        def split_period(period):
+            dates = period.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['period'].apply(lambda x: pd.Series(split_period(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='role', model_name='text-embedding-3-small'):
+        """
+        Calculates the embeddings for a column in a dataframe using the OpenAI API.
+        
+            df (pandas.DataFrame): DataFrame containing the CV data.
+            column (str, optional): Name of the column containing the text to be converted to embeddings. Default is 'role'.
+            model_name (str, optional): Name of the embeddings model. Default is 'text-embedding-3-small'.
+            
+        Returns:
+            pandas.DataFrame: DataFrame with an additional 'embeddings' column containing the generated embeddings.
+        """
+        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'):
+        """
+        Calculates the cosine distance between the text embeddings and those included in a DataFrame column.
+        Parameters:
+        -----------
+        df : pandas.DataFrame
+            DataFrame containing the embeddings.
+        column : str, optional
+            Name of the DataFrame column containing the embeddings. Default is 'embeddings'.
+        model_name : str, optional
+            OpenAI API embedding model. Default is "text-embedding-3-small".
+        --------
+        pandas.DataFrame
+            DataFrame sorted by distance in ascending order, with distances added as a new column.
+        """
+        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):
+        """
+
+        Calculates the score of a CV based on its distance table (relative to a given position) and durations.
+        Parameters:
+        ----------
+        df : pandas.DataFrame
+            CV data including different experiences with durations and distances previously calculated based on the embeddings of a job position.
+        req_experience : float
+            Required experience in months for the job position (reference value to calculate a score between 0 and 100 based on different experiences).
+        positions_cap : int, optional
+            Maximum number of positions to consider for scoring. Defaults to 4.
+        dist_threshold_low : float, optional
+            Distance between embeddings below which the CV position is considered "equivalent" to the job offer. Defaults to 0.6.
+        dist_threshold_high : float, optional
+            Distance between embeddings above which the CV position does not score. Defaults to 0.7.
+        -------
+        pandas.DataFrame
+            Original DataFrame with an additional column containing individual scores contributed by each position.
+        float
+            Total score between 0 and 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):
+        """
+        Filters the relevant experiences from the dataframe and returns them in dictionary format.
+        Args:
+            df (pandas.DataFrame): DataFrame with complete experience information.
+        Returns:
+            dict: Dictionary with the relevant experiences.
+        """
+        df_experiencia =  df[df['position_score'] > 0].copy()
+        df_experiencia.drop(columns=['period', '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):
+        """
+        Makes the final call to the language model to generate the final response.
+            req_experience (int): Required experience in months for the job position.
+            puntuacion (float): Total score of the CV.
+            dict_experiencia (dict): Dictionary with relevant experiences.
+            dict: Dictionary with the final response.
+        Raises:
+            ValueError: If no response is generated by the language model.
+        """
+        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": "Returns an object with score, experience and description of the experience",
+                "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("Response:\n", json.dumps(structured_output, indent=4, ensure_ascii=False))
+            wrapped_description = textwrap.fill(structured_output['experience summary'], width=120)
+            print(f"Experience summary:\n{wrapped_description}")
+            return structured_output
+        else:
+            raise ValueError(f"Error. No response was generated:\n {response.choices[0].message.content}")
+    
+    def procesar_cv_completo(self, req_experience, positions_cap, dist_threshold_low, dist_threshold_high):
+        '''
+        Processes a CV and calculates the final score.
+            req_experience (int, optional): Required experience in months for the job position.
+            positions_cap (int, optional): Maximum number of positions to consider for scoring.
+            dist_threshold_low (float, optional): Distance limit to consider a position equivalent.
+            dist_threshold_high (float, optional): Distance limit to consider a position not relevant.
+        Returns:
+            dict: Dictionary with the final answer.
+        '''
+        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