@odda-ai/matching-core 1.0.0

package/src/features/prompts.ts

@@ -0,0 +1,621 @@
+export const CV_ANALYSIS_PROMPT_V1 = (
+  cvText: string,
+) => `
+Sei un esperto analista HR specializzato nell’analisi di curriculum vitae.  
+Il tuo compito è analizzare il seguente CV ed estrarre informazioni strutturate in formato JSON.
+
+**CV da Analizzare:**  
+${cvText}
+
+---
+
+## Istruzioni Ultra-Stabili:
+
+### 0. Dati Anagrafici (Massima Priorità)
+- Estrai tutti i dati personali disponibili:
+  - \`firstName\` (OBBLIGATORIO, se non trovato usare \`"N/A"\`)
+  - \`lastName\` (OBBLIGATORIO, se non trovato usare \`"N/A"\`)
+  - \`email\`, \`phone\`, \`address\`, \`dateOfBirth\` (YYYY-MM-DD), \`nationality\`, \`linkedIn\`, \`github\`, \`website\` (opzionali, usare \`null\` se mancanti)
+- Cerca nell’intestazione e nel corpo del CV.
+- Mantieni sempre lo stesso ordine dei campi JSON.
+
+### 1. Profilo Professionale
+- Breve descrizione (max 2-3 frasi) con:
+  - Ruolo principale
+  - Anni totali di esperienza
+  - Aree di specializzazione chiave
+- Tono professionale e oggettivo.
+
+### 2. Skills Tecniche (Massima Stabilità)
+- Estrai **solo skills esplicitamente menzionate**.
+- Per ciascuna skill:
+  - \`proficiency\`: 0-100, calcolato rigidamente:
+    - Hobby/progetti personali: 20  
+    - Progetti professionali base: 50  
+    - Progetti professionali avanzati / responsabilità senior: 80  
+    - Expertise avanzata / certificazioni: 90  
+    - Bonus certificazioni avanzate: +10 (non oltre 100)
+  - \`seniority\`: basato sugli anni di esperienza specifica:
+    - JUNIOR: 0-2 anni  
+    - MID: 2-5 anni  
+    - SENIOR: 5-10 anni  
+    - LEAD: 10-15 anni  
+    - PRINCIPAL: 15+ anni
+  - \`experience\`: mesi di esperienza se menzionati, altrimenti \`null\`
+  - \`isInferred\`: false
+- Inferisci **solo skills strettamente correlate** (max 5):
+  - React → JavaScript, HTML, CSS  
+  - NestJS → Node.js, TypeScript  
+  - PostgreSQL → SQL  
+  - DevOps → Linux, Docker, Git
+  - Attingi anche da descrizioni di progetti e responsabilità o da una statistica generale, non solo dalla sezione skills.
+- Per skill inferite:
+  - \`proficiency\`: 30-50
+  - \`seniority\`: uguale o inferiore alla skill correlata
+  - \`isInferred\`: true
+- Usa \`referenceSkills\` per matching e inferenza coerente.
+- Ordina sempre le skills in ordine alfabetico per consistenza.
+
+### 3. Esperienze Lavorative
+- Seleziona 2-3 posizioni più rilevanti (cronologico inverso).
+- Per ciascuna posizione:
+  - \`companyName\`
+  - \`role\`
+  - \`durationInYears\` (arrotondato a 0.5 anni)
+  - \`mainResponsibility\` (max 1 frase)
+- Massimo 4-5 frasi totali.
+
+### 4. Certificazioni
+- Estrai tutte le certificazioni con:
+  - \`name\`
+  - \`issuer\` (se disponibile)
+  - \`year\` (se disponibile)
+- Se assenti, restituire array vuoto.
+
+### 5. Seniority Complessiva
+- Basata su:
+  - Anni totali esperienza
+  - Livello dei ruoli ricoperti
+  - Numero di skills con \`proficiency ≥ 80\`
+  - Presenza di certificazioni avanzate
+- Scala rigida:
+  - JUNIOR: 0-2 anni  
+  - MID: 2-5 anni  
+  - SENIOR: 5-10 anni  
+  - LEAD: 10-15 anni  
+  - PRINCIPAL: 15+ anni
+
+### 6. Anni di Esperienza Totale
+- Somma esperienze lavorative professionali, **escludendo stage e hobby projects**.
+- Se non esplicitati, inferire dai ruoli principali.
+
+---
+
+## Formato JSON Richiesto
+Restituisci **solo un JSON valido**, senza markdown:
+
+\`\`\`json
+{
+  "personalInfo": {
+    "firstName": "Mario",
+    "lastName": "Rossi",
+    "email": "mario.rossi@example.com",
+    "phone": "+39 348 1234567",
+    "address": "Via Roma 123, Milano, Italia",
+    "dateOfBirth": "1990-05-15",
+    "nationality": "Italiana",
+    "linkedIn": "https://linkedin.com/in/mariorossi",
+    "github": "https://github.com/mariorossi",
+    "website": "https://mariorossi.dev"
+  },
+  "description": "Breve descrizione professionale",
+  "technicalSkills": [
+    {
+      "name": "NomeSkill",
+      "proficiency": 85,
+      "isInferred": false,
+      "seniority": "SENIOR",
+      "experience": 36
+    }
+  ],
+  "workExperienceSummary": "Riassunto esperienze rilevanti",
+  "certifications": [
+    {
+      "name": "Nome Certificazione",
+      "issuer": "Ente Certificatore",
+      "year": 2023
+    }
+  ],
+  "overallSeniority": "SENIOR",
+  "yearsOfExperience": 8
+}
+
+\`\`\`
+
+Note Finali
+- Rispondi SOLO con JSON valido.
+- firstName e lastName obbligatori ("N/A" se mancanti).
+- Tutti gli altri campi obbligatori (array vuoti se assenti).
+- Mantieni coerenza e ripetibilità dei punteggi e inferenze tra CV simili.
+`;
+
+
+export const CV_ANALYSIS_PROMPT = (
+  cvText: string,
+) => `# Prompt Analisi CV in JSON – Versione Ultra-Stabile
+
+Sei un esperto analista HR specializzato nell’analisi di curriculum vitae.  
+Il tuo compito è analizzare il CV fornito e restituire un JSON strutturato con tutte le informazioni principali.
+
+**CV da Analizzare:**  
+${cvText}
+
+---
+
+## Istruzioni Ultra-Stabili:
+
+### 0. Dati Anagrafici (Massima Priorità)
+- Estrai tutti i dati personali disponibili:
+  - \`firstName\` (OBBLIGATORIO, se non trovato usare \`"N/A"\`)
+  - \`lastName\` (OBBLIGATORIO, se non trovato usare \`"N/A"\`)
+  - \`email\`, \`phone\`, \`address\`, \`dateOfBirth\` (YYYY-MM-DD), \`nationality\`, \`linkedIn\`, \`github\`, \`website\` (opzionali, usare \`null\` se mancanti)
+- Cerca informazioni nell’intestazione e nel corpo del CV.
+- Se la data di nascita contiene solo anno/mese, completare con giorno \`01\`.
+
+---
+
+### 1. Profilo Professionale
+- Breve descrizione (max 2-3 frasi) con:
+  - Ruolo principale
+  - Anni totali di esperienza
+  - Settore/industria
+  - Aree di specializzazione chiave
+- Tono professionale e oggettivo.
+
+---
+
+### 2. Skills Tecniche (Massima Stabilità)
+
+#### 2.1 Estrazione esplicita
+- Considera **solo le skills menzionate testualmente** nelle sezioni “Competenze”, “Skills”, “Progetti”, “Esperienze” o “Certificazioni tecniche”.
+- Per ciascuna skill:
+  - \`name\` → come scritto nel CV (normalizzato per coerenza)
+  - \`proficiency\` → calcolato rigidamente:
+    - Hobby/progetti personali: 20  
+    - Progetti professionali base: 50  
+    - Progetti professionali avanzati / responsabilità senior: 80  
+    - Expertise avanzata / certificazioni: 90  
+    - Bonus certificazioni avanzate: +10 (max 100)
+  - \`seniority\` → basato sugli anni di esperienza specifica:
+    - JUNIOR: 0-2 anni  
+    - MID: 2-5 anni  
+    - SENIOR: 5-10 anni  
+    - LEAD: 10-15 anni  
+    - PRINCIPAL: 15+ anni
+  - \`experience\` → mesi esplicitamente menzionati o \`null\`
+  - \`isInferred\` → false
+
+#### 2.2 Inferenza di skill correlate
+- Solo per skill tecniche note, massimo 5 inferenze per CV.
+- Mappe di inferenza (referenceSkills):
+  - React → JavaScript, TypeScript, HTML, CSS, JSX, Redux, Hooks, Context API, Router, SSR, Testing, Recoil, Zustand, Framer Motion, GSAP, Storybook, Playwright, Web Vitals
+  - Angular → TypeScript, HTML, CSS, RxJS, NgRx, CLI, DI, Testing, PWA, Lazy Loading
+  - Vue → JavaScript, TypeScript, HTML, CSS, Vuex, Router, Composition API, SSR, Testing, Pinia
+  - Node.js → JavaScript, TypeScript, Async/Await, Express.js, NestJS, REST, GraphQL, WebSockets, Microservices, Testing, gRPC, Thrift, Kafka, Celery, BullMQ
+  - NestJS → Node.js, TypeScript, REST, GraphQL, DI, Modules, Middleware, Pipes, Guards, Interceptors, TypeORM/Prisma
+  - Python → OOP, Async, Flask, Django, FastAPI, Testing, Pandas, NumPy, ML, gRPC, Kafka, Airflow, Prefect, MLflow, Kubeflow, Triton
+  - Java → OOP, Spring Boot, REST, Microservices, Concurrency, Testing, gRPC, Kafka
+  - C# → OOP, .NET Core, ASP.NET, REST, Microservices, Testing, gRPC
+  - SQL → PostgreSQL, MySQL, SQL Server, Oracle, Indexing, Joins, Transactions, Views, Procedures, TimescaleDB
+  - NoSQL → MongoDB, Redis, Cassandra, Aggregation, Replication, Sharding, Caching, Neo4j, ArangoDB, Elasticsearch, Meilisearch
+  - Redis → Caching, Pub/Sub, Session Management, Performance
+  - Messaging → RabbitMQ, Kafka, Event-driven, Queues, Retry, Streaming
+  - Docker → Containers, Images, Volumes, Networking, CI/CD, Security
+  - Kubernetes → Pods, Deployments, Services, Ingress, ConfigMaps, Secrets, Helm, Scaling, Observability
+  - DevOps → Linux, Git, CI/CD, Docker, Kubernetes, Monitoring, Logging, Cloud, Security, Terraform, Pulumi, CloudFormation, Vault, SOPS, Serverless Framework, SST
+  - Git → Version Control, Branching, Merging, PR
+  - Linux → Shell, Networking, Permissions, Cron, Systemd
+  - Cloud → AWS (EC2,S3,Lambda,RDS,IAM), GCP (Compute,Storage,Functions,BigQuery), Azure (VM,App,Functions,SQL), Edge/CDN (Cloudflare Workers, Fastly)
+  - REST API → HTTP, JSON, CRUD, Auth, Rate Limiting, Testing
+  - GraphQL → Schema, Resolvers, Subscriptions, Apollo, Caching
+  - Testing → Unit, Integration, E2E, TDD, BDD, Jest, Mocha, Cypress, Selenium, Postman/Newman
+  - CI/CD → Jenkins, GitHub Actions, GitLab CI, Pipelines, Rollbacks, Blue/Green
+  - Security → Auth, JWT, OAuth2, HTTPS, CORS, Encryption, Input Validation, Secrets, SAST, DAST, PenTesting, Keycloak, Auth0, Container Security
+  - Monitoring → Prometheus, Grafana, ELK, CloudWatch, Metrics, Tracing, OpenTelemetry, Datadog
+  - Microservices → Service Discovery, API Gateway, Event-driven, Circuit Breaker, CQRS, Saga, Serverless
+  - Architecture → MVC, MVVM, Layered, Event-driven, Serverless, Monolith vs Microservices, DDD, Hexagonal, Clean Architecture, Multi-tenant, SaaS Patterns
+  - Performance → Caching, Load Balancing, Scaling, DB Optimization, Code Splitting, Lazy Loading, CDN
+
+- Per skill inferite:
+  - \`proficiency\` : 30-70 (inferiore o uguale alla skill madre, assegna un valore realistico in base alla relazione)  
+  - \`seniority\`: uguale o inferiore alla skill madre  
+  - \`experience\`: null  
+  - \`isInferred\`: true  
+  - \`source\`: opzionale, “inferred from {skill madre}”
+
+#### 2.3 Ordinamento
+- Ordinare alfabeticamente tutte le skill, prima esplicite, poi inferite.
+
+---
+
+### 3. Esperienze Lavorative
+- Seleziona 2-3 posizioni più rilevanti, cronologico inverso.
+- Per ciascuna posizione:
+  - \`companyName\`
+  - \`role\`
+  - \`durationInYears\` (arrotondato a 0.5)
+  - \`mainResponsibility\` (max 1 frase)
+- Escludere stage o hobby projects dai calcoli di esperienza.
+
+---
+
+### 4. Certificazioni
+- Estrarre tutte le certificazioni con:
+  - \`name\` (OBBLIGATORIO)
+  - \`issuer\` (null se non disponibile)
+  - \`year\` (null se non disponibile)
+- Se assenti, restituire array vuoto.
+
+---
+
+### 5. Seniority Complessiva
+- Basata su:
+  - Anni totali esperienza
+  - Livello dei ruoli ricoperti
+  - Numero di skill con \`proficiency ≥ 80\`
+  - Presenza di certificazioni avanzate
+- Scala:
+  - JUNIOR: 0-2 anni  
+  - MID: 2-5 anni  
+  - SENIOR: 5-10 anni  
+  - LEAD: 10-15 anni  
+  - PRINCIPAL: 15+ anni
+
+---
+
+### 6. Anni di Esperienza Totale
+- Somma esperienze lavorative professionali, **escludendo stage e hobby projects**.
+- Se non esplicitati, inferire dai ruoli principali.
+
+---
+
+## Formato JSON Richiesto
+Restituire **solo un JSON valido**, senza markdown.
+
+\`\`\`json
+{
+  "personalInfo": {
+    "firstName": "N/A",
+    "lastName": "N/A",
+    "email": null,
+    "phone": null,
+    "address": null,
+    "dateOfBirth": null,
+    "nationality": null,
+    "linkedIn": null,
+    "github": null,
+    "website": null
+  },
+  "description": "Breve descrizione professionale",
+  "technicalSkills": [
+    {
+      "name": "NomeSkill",
+      "proficiency": 85,
+      "isInferred": false,
+      "seniority": "SENIOR",
+      "experience": 36
+    }
+  ],
+  "workExperienceSummary": "Riassunto esperienze rilevanti",
+  "certifications": [
+    {
+      "name": "Nome Certificazione",
+      "issuer": "Ente Certificatore",
+      "year": 2023
+    }
+  ],
+  "overallSeniority": "SENIOR",
+  "yearsOfExperience": 8
+}
+`;
+
+export const JOB_MATCHING_PROMPT_V1 = (
+  jobDescription: string,
+  skillsList: string[],
+) => `Task: Perform end-to-end skill extraction, semantic matching, and scoring.
+
+Input:
+- Job Description: ${jobDescription}
+- List of Reference Skills:
+${skillsList.map((skill) => `    - ${skill}`).join("\n")}
+
+Instructions:
+
+1. Skill Extraction & Normalization
+- Extract all relevant technical and soft skills from the Job Description
+- Include explicit and clearly inferable implicit skills
+- Normalize all skills to canonical names
+- Map overly specific skills to their broader parent skills when appropriate
+
+2. Skill Importance Classification
+For each extracted skill, determine its importance for the role:
+- core: essential to perform the job
+- enabling: improves effectiveness
+- nice_to_have: optional or contextual
+
+3. Semantic Matching
+For each Reference Skill:
+- Evaluate semantic similarity with extracted skills
+- Consider hierarchical and functional relationships (general ↔ specific)
+- Recognize equivalent or alternative skills covering the same domain
+- Do not penalize missing overly specific skills when a broader equivalent exists
+
+4. Scoring
+Assign a multiplier between 0.00 and 1.00 based on:
+- Semantic similarity
+- Importance of the matched extracted skill
+- Functional coverage by alternative skills
+- Realistic expectations in a recruiting context
+
+Scoring guidelines:
+- 0.80–1.00 → crucial and strongly matched
+- 0.50–0.79 → relevant or partially matched
+- 0.20–0.49 → weak or indirect relevance
+- < 0.20 → exclude from output
+
+5. Output
+Return ONLY a valid JSON array.
+Include only Reference Skills with multiplier > 0.
+
+Output format:
+[
+  { "skill": "Exact Reference Skill Name", "multiplier": 0.00 }
+]
+
+Constraints:
+- Do NOT include markdown
+- Do NOT include explanations
+- Do NOT include intermediate steps
+- Return ONLY the final JSON array
+
+Example:
+
+Job Description:
+"Looking for a Frontend Engineer with strong React experience.
+You will collaborate with designers and backend engineers.
+Experience with modern state management libraries is a plus."
+
+Reference Skills:
+- React
+- Redux
+- Zustand
+- Communication
+- AWS
+
+Expected Output:
+[
+  { "skill": "React", "multiplier": 0.95 },
+  { "skill": "Redux", "multiplier": 0.60 },
+  { "skill": "Zustand", "multiplier": 0.55 },
+  { "skill": "Communication", "multiplier": 0.40 }
+]
+`;
+
+export const JOB_MATCHING_PROMPT = (
+  jobDescription: string,
+  skillsList: string[],
+) => `# TASK
+Perform two-pass deterministic skill extraction with validation, normalization, semantic alignment, classification, and scoring.
+
+Precision target: ~90%.  
+Priority: avoid hallucinations and unjustified inferences.
+
+Extraction must be text-grounded and validated before final output.
+
+---
+
+# INPUT
+
+## Job Description
+${jobDescription}
+
+## Reference Skills
+${skillsList.map((skill) => `- ${skill}`).join("\n")}
+
+---
+
+# GLOBAL RULES
+
+1. Do NOT invent skills.
+2. Do NOT use external knowledge.
+3. Do NOT assume standard tech stacks.
+4. Do NOT infer from job title alone.
+5. Every skill must be grounded in explicit text or strictly necessary logic.
+6. If uncertain → remove the skill.
+7. Precision > Recall.
+
+---
+
+# PASS 1 — CONTROLLED EXTRACTION
+
+Extract ALL candidate skills that satisfy one of the following:
+
+### A) Explicit Mention
+Skill is directly written in the Job Description.
+
+### B) Deterministic Logical Necessity (STRICT)
+Infer ONLY if:
+- The responsibility cannot be performed without that skill.
+- The inference is structurally required.
+- The inference does not depend on market assumptions.
+
+Allowed examples:
+- “Build REST APIs” → REST
+- “Write unit tests” → Unit Testing
+- “Design relational database schema” → SQL
+
+Forbidden examples:
+- “Frontend Developer” → React
+- “Cloud environment” → AWS
+- “Agile team” → Scrum
+- “Microservices” → Docker
+
+For each candidate skill:
+- Normalize to canonical name.
+- Remove duplicates.
+- Classify category:
+  - technical
+  - soft
+
+---
+
+# PASS 2 — VALIDATION & PRUNING (CRITICAL FOR 90% PRECISION)
+
+For EACH extracted skill, validate:
+
+1. Can I point to a direct phrase in the Job Description supporting this skill?
+2. Is the inference strictly necessary (not assumed)?
+3. Would a human reviewer agree this skill is clearly implied?
+
+If ANY answer is uncertain → REMOVE the skill.
+
+Do NOT keep borderline skills.
+Do NOT keep ecosystem expansions.
+Do NOT broaden vendor-specific tools unless explicitly stated.
+
+After pruning:
+The remaining list becomes the FINAL extracted skill set.
+
+---
+
+# IMPORTANCE CLASSIFICATION (TEXT-DRIVEN ONLY)
+
+Use only explicit textual signals.
+
+CORE:
+- must
+- required
+- essential
+- primary responsibility
+- strongly emphasized
+
+ENABLING:
+- preferred
+- experience with
+- plus
+- good to have
+- improves execution
+
+NICE_TO_HAVE:
+- optional
+- secondary section
+- clearly non-blocking
+
+If ambiguous → classify as ENABLING.
+Never upgrade importance without textual evidence.
+
+---
+
+# REFERENCE SKILL MAPPING (AFTER VALIDATION ONLY)
+
+For each validated extracted skill:
+
+Step 1: Attempt exact match (case-insensitive).
+Step 2: If no exact match → attempt strict semantic equivalence.
+Step 3: If semantic confidence is not high → DO NOT MAP.
+
+Mapping constraints:
+- Only map when meaning is substantially identical.
+- Do NOT map broader ↔ narrower unless coverage is complete.
+- Do NOT force mapping.
+
+If mapped:
+- Use exact Reference Skill name.
+- "isReferenceSkill": true
+
+If not mapped:
+- Keep normalized extracted name.
+- "isReferenceSkill": false
+
+Never remove unmatched skills.
+
+---
+
+# MULTIPLIER SCORING (DETERMINISTIC RANGE SYSTEM)
+
+Scoring depends ONLY on:
+- Importance
+- Mapping status
+
+No subjective creativity.
+
+If isReferenceSkill = true:
+
+CORE → 0.90–1.00  
+ENABLING → 0.65–0.80  
+NICE_TO_HAVE → 0.40–0.55  
+
+If isReferenceSkill = false:
+
+CORE → 0.80–0.90  
+ENABLING → 0.55–0.70  
+NICE_TO_HAVE → 0.30–0.50  
+
+Rules:
+- Default to mid-range value.
+- Use upper bound only if strongly emphasized.
+- Never assign 1.00 unless clearly critical.
+- Exclude skills with multiplier < 0.30.
+
+---
+
+# JOB SKILL TYPE ASSIGNMENT
+
+If category = technical:
+- core OR enabling → technical_required
+- nice_to_have → technical_nice_to_have
+
+If category = soft:
+- core OR enabling → soft_required
+- nice_to_have → soft_nice_to_have
+
+Allowed values only:
+- technical_required
+- technical_nice_to_have
+- soft_required
+- soft_nice_to_have
+
+---
+
+# OUTPUT RULES (STRICT)
+
+Return ONLY a valid JSON array.
+
+- No markdown
+- No explanations
+- No reasoning
+- No comments
+- No intermediate steps
+- No extra fields
+- Include only skills with multiplier ≥ 0.30
+- Include both mapped and unmapped skills
+- If no skills validated → return []
+
+---
+
+# OUTPUT FORMAT
+
+[
+  {
+    "skill": "Final Skill Name",
+    "multiplier": 0.00,
+    "jobSkillType": "technical_required | technical_nice_to_have | soft_required | soft_nice_to_have",
+    "isReferenceSkill": true | false
+  }
+]
+\`\`\``;
+
+export const prompts = {
+  cvAnalysis: CV_ANALYSIS_PROMPT,
+  jobMatching: JOB_MATCHING_PROMPT,
+};

package/src/features/system-messages.ts

@@ -0,0 +1,28 @@
+export const ANALYZE_RESUME: () => string | undefined = () => undefined;
+export const JOB_MATCHING = () => `
+You are a senior HR Analytics and Skill Intelligence expert specialized in realistic AI-based recruiting systems.
+
+You work with noisy job descriptions, implicit requirements, rare skills, and non-standardized taxonomies.
+
+You MUST follow these principles:
+- Skills are semantic concepts, not keywords
+- Overly specific skills must never be treated as hard requirements
+- Implicit skills may be inferred only when clearly supported by responsibilities
+- Soft skills are supporting signals, never exclusion criteria
+- Matching must be realistic, recruiter-aligned, and explainable
+
+Operational constraints:
+- Normalize and canonicalize skill names
+- Evaluate skill importance (core / enabling / nice-to-have)
+- Prefer realistic recall over overly strict precision
+- Do not invent unjustified skills
+
+Output discipline:
+- When structured output is requested, return ONLY valid JSON
+- Do not include explanations, markdown, or extra text
+`;
+
+export const systemMessages = {
+  analyzeResume: ANALYZE_RESUME,
+  jobMatching: JOB_MATCHING,
+};

package/src/features/types.ts

@@ -0,0 +1,55 @@
+export enum Seniority {
+  JUNIOR = 'JUNIOR',
+  MID = 'MID',
+  SENIOR = 'SENIOR',
+  LEAD = 'LEAD',
+  PRINCIPAL = 'PRINCIPAL',
+}
+
+export enum JobSkillType {
+  TECHNICAL_REQUIRED = 'technical_required',
+  TECHNICAL_NICE_TO_HAVE = 'technical_nice_to_have',
+  SOFT_REQUIRED = 'soft_required',
+  SOFT_NICE_TO_HAVE = 'soft_nice_to_have',
+}
+
+export type TechnicalSkill = {
+  name: string;
+  proficiency: number;
+  isInferred: boolean;
+  seniority: Seniority;
+}
+
+export type PersonalInfo = {
+  firstName?: string;
+  lastName?: string;
+  email?: string;
+  phone?: string;
+  address?: string;
+  dateOfBirth?: string;
+  nationality?: string;
+  linkedIn?: string;
+  github?: string;
+  website?: string;
+}
+
+export type Certification = {
+  name: string;
+  issuer?: string;
+  year?: number;
+}
+
+export type CvAnalysisRequest = {
+  cvText: string;
+  referenceSkills?: string[];
+}
+
+export type CvAnalysisResponse = {
+  personalInfo: PersonalInfo;
+  description: string;
+  technicalSkills: TechnicalSkill[];
+  workExperienceSummary: string;
+  certifications: Certification[];
+  overallSeniority: Seniority;
+  yearsOfExperience: number;
+}