diff --git a/README.md b/README.md
index 5d97073..180e085 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# Autoparts DB
+# Nexus Autoparts
 
-Sistema completo de gestión de base de datos de vehículos y autopartes con dashboard web, herramientas de web scraping y múltiples interfaces de consulta.
+Sistema completo de gestión de base de datos de vehículos y nexus-autoparts con dashboard web, herramientas de web scraping y múltiples interfaces de consulta.
 
 ## Descripción
 
-**Autoparts DB** es una solución integral para la gestión de información de vehículos que incluye:
+**Nexus Autoparts** es una solución integral para la gestión de información de vehículos que incluye:
 
 - Base de datos SQLite normalizada con información de marcas, modelos, motores y años
 - Dashboard web moderno y responsivo para consultar y explorar datos
@@ -105,8 +105,8 @@ Funcionalidades: navegación por vehículo (marca→modelo→año→motor), bús
 
 1. **Clonar el repositorio**
    ```bash
-   git clone https://git.consultoria-as.com/[usuario]/Autoparts-DB.git
-   cd Autoparts-DB
+   git clone https://git.consultoria-as.com/[usuario]/Nexus-Autoparts.git
+   cd Nexus-Autoparts
    ```
 
 2. **Instalar dependencias**
@@ -330,4 +330,4 @@ Para más información, contactar al equipo de desarrollo.
 
 ---
 
-**Autoparts DB** - Sistema de Gestión de Base de Datos de Vehículos
+**Nexus Autoparts** - Sistema de Gestión de Base de Datos de Vehículos
diff --git a/config.py b/config.py
new file mode 100644
index 0000000..498d847
--- /dev/null
+++ b/config.py
@@ -0,0 +1,20 @@
+"""
+Central configuration for Nexus Autoparts.
+"""
+import os
+
+# Database
+DB_URL = os.environ.get(
+    "DATABASE_URL",
+    "postgresql://nexus:nexus_autoparts_2026@localhost/nexus_autoparts"
+)
+
+# Legacy SQLite path (used only by migration script)
+SQLITE_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)),
+    "vehicle_database", "vehicle_database.db"
+)
+
+# Application identity
+APP_NAME = "NEXUS AUTOPARTS"
+APP_SLOGAN = "Tu conexión directa con las partes que necesitas"
diff --git a/console/README.md b/console/README.md
index 76ae019..ecca030 100644
--- a/console/README.md
+++ b/console/README.md
@@ -1,6 +1,6 @@
-# AUTOPARTES Console - Sistema Pick/VT220
+# NEXUS AUTOPARTS Console - Sistema Pick/VT220
 
-Interfaz de consola para el catálogo de autopartes, inspirada en los sistemas Pick/D3 con estética de terminal VT220. Funciona 100% con teclado, verde sobre negro.
+Interfaz de consola para el catálogo de nexus-autoparts, inspirada en los sistemas Pick/D3 con estética de terminal VT220. Funciona 100% con teclado, verde sobre negro.
 
 ## Requisitos
 
diff --git a/console/config.py b/console/config.py
index 875361f..f17c409 100644
--- a/console/config.py
+++ b/console/config.py
@@ -1,18 +1,18 @@
 """
-Configuration settings for the AUTOPARTES console application.
+Configuration settings for the NEXUS AUTOPARTS console application.
 """
 
 import os
+import sys
 
 # Application metadata
-VERSION = "1.0.0"
-APP_NAME = "AUTOPARTES"
-APP_SUBTITLE = "Sistema de Catalogo de Autopartes"
+VERSION = "2.0.0"
+APP_NAME = "NEXUS AUTOPARTS"
+APP_SUBTITLE = "Tu conexión directa con las partes que necesitas"
 
-# Database path (relative to the console/ directory, resolved to absolute)
-_CONSOLE_DIR = os.path.dirname(os.path.abspath(__file__))
-DB_PATH = os.path.join(_CONSOLE_DIR, "..", "vehicle_database", "vehicle_database.db")
-DB_PATH = os.path.normpath(DB_PATH)
+# Database URL (PostgreSQL)
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
+from config import DB_URL
 
 # NHTSA VIN Decoder API
 NHTSA_API_URL = "https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVin"
diff --git a/console/core/app.py b/console/core/app.py
index 784adae..75eece9 100644
--- a/console/core/app.py
+++ b/console/core/app.py
@@ -1,5 +1,5 @@
 """
-Main application controller for the AUTOPARTES console application.
+Main application controller for the NEXUS AUTOPARTS console application.
 
 The :class:`App` class owns the screen lifecycle loop: it renders the
 current screen, reads a keypress, dispatches it, and follows any
diff --git a/console/db.py b/console/db.py
index d691a4c..84b3cf1 100644
--- a/console/db.py
+++ b/console/db.py
@@ -1,56 +1,64 @@
 """
-Database abstraction layer for the AUTOPARTES console application.
+Database abstraction layer for the NEXUS AUTOPARTS console application.
 
 Provides all data access methods the console app needs, reading from the
-same SQLite database used by the Flask web dashboard.
+PostgreSQL database used by the Flask web dashboard.
 """
 
-import sqlite3
+import json as json_module
 from datetime import datetime, timedelta
 from typing import Optional
 
-from console.config import DB_PATH
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
+from config import DB_URL
 
 
 class Database:
-    """Thin abstraction over the vehicle_database SQLite database."""
+    """Thin abstraction over the nexus_autoparts PostgreSQL database."""
 
-    def __init__(self, db_path: Optional[str] = None):
-        self.db_path = db_path or DB_PATH
-        self._conn: Optional[sqlite3.Connection] = None
+    def __init__(self, db_url: Optional[str] = None):
+        self.db_url = db_url or DB_URL
+        self._engine = None
+        self._Session = None
         self._cache: dict = {}
 
     # ------------------------------------------------------------------
     # Private helpers
     # ------------------------------------------------------------------
 
-    def _connect(self) -> sqlite3.Connection:
-        """Return persistent connection (created once, reused)."""
-        if self._conn is None:
-            self._conn = sqlite3.connect(self.db_path)
-            self._conn.row_factory = sqlite3.Row
-            self._conn.execute("PRAGMA journal_mode=WAL")
-            self._conn.execute("PRAGMA cache_size=-8000")  # 8MB cache
-            self._conn.execute("PRAGMA mmap_size=67108864")  # 64MB mmap
-        return self._conn
+    def _get_engine(self):
+        if self._engine is None:
+            self._engine = create_engine(self.db_url, pool_pre_ping=True)
+            self._Session = sessionmaker(bind=self._engine)
+        return self._engine
+
+    def _session(self):
+        self._get_engine()
+        return self._Session()
 
     def close(self):
-        """Close the persistent connection."""
-        if self._conn is not None:
-            self._conn.close()
-            self._conn = None
+        """Dispose the engine connection pool."""
+        if self._engine is not None:
+            self._engine.dispose()
+            self._engine = None
+            self._Session = None
 
-    def _query(self, sql: str, params: tuple = (), one: bool = False):
+    def _query(self, sql: str, params: dict = None, one: bool = False):
         """Execute a SELECT and return list[dict] (or a single dict if *one*)."""
-        conn = self._connect()
-        cursor = conn.cursor()
-        cursor.execute(sql, params)
-        if one:
-            row = cursor.fetchone()
-            return dict(row) if row else None
-        return [dict(r) for r in cursor.fetchall()]
+        session = self._session()
+        try:
+            rows = session.execute(text(sql), params or {}).mappings().all()
+            if one:
+                return dict(rows[0]) if rows else None
+            return [dict(r) for r in rows]
+        finally:
+            session.close()
 
-    def _query_cached(self, cache_key: str, sql: str, params: tuple = ()):
+    def _query_cached(self, cache_key: str, sql: str, params: dict = None):
         """Execute a SELECT with in-memory caching for repeated queries."""
         if cache_key in self._cache:
             return self._cache[cache_key]
@@ -58,14 +66,20 @@ class Database:
         self._cache[cache_key] = result
         return result
 
-    def _execute(self, sql: str, params: tuple = ()) -> int:
-        """Execute an INSERT/UPDATE/DELETE and return lastrowid."""
-        conn = self._connect()
-        cursor = conn.cursor()
-        cursor.execute(sql, params)
-        conn.commit()
-        self._cache.clear()  # invalidate cache on writes
-        return cursor.lastrowid
+    def _execute(self, sql: str, params: dict = None) -> Optional[int]:
+        """Execute an INSERT/UPDATE/DELETE. Returns scalar result if RETURNING used."""
+        session = self._session()
+        try:
+            result = session.execute(text(sql), params or {})
+            session.commit()
+            self._cache.clear()
+            # If the query has RETURNING, get the scalar
+            try:
+                return result.scalar()
+            except Exception:
+                return None
+        finally:
+            session.close()
 
     # ==================================================================
     # Vehicle navigation
@@ -75,7 +89,7 @@ class Database:
         """Return all brands ordered by name: [{id, name, country}]."""
         return self._query_cached(
             "brands",
-            "SELECT id, name, country FROM brands ORDER BY name",
+            "SELECT id_brand AS id, name_brand AS name, country FROM brands ORDER BY name_brand",
         )
 
     def get_models(self, brand: Optional[str] = None) -> list[dict]:
@@ -85,18 +99,18 @@ class Database:
             return self._query_cached(
                 key,
                 """
-                SELECT MIN(m.id) AS id, m.name
+                SELECT MIN(m.id_model) AS id, m.name_model AS name
                 FROM models m
-                JOIN brands b ON m.brand_id = b.id
-                WHERE UPPER(b.name) = UPPER(?)
-                GROUP BY UPPER(m.name)
-                ORDER BY m.name
+                JOIN brands b ON m.brand_id = b.id_brand
+                WHERE b.name_brand ILIKE :brand
+                GROUP BY UPPER(m.name_model), m.name_model
+                ORDER BY m.name_model
                 """,
-                (brand,),
+                {"brand": brand},
             )
         return self._query_cached(
             "models:all",
-            "SELECT MIN(id) AS id, name FROM models GROUP BY UPPER(name) ORDER BY name",
+            "SELECT MIN(id_model) AS id, name_model AS name FROM models GROUP BY UPPER(name_model), name_model ORDER BY name_model",
         )
 
     def get_years(
@@ -104,22 +118,22 @@ class Database:
     ) -> list[dict]:
         """Return years, optionally filtered by brand and/or model."""
         sql = """
-            SELECT DISTINCT y.id, y.year
+            SELECT DISTINCT y.id_year AS id, y.year_car AS year
             FROM years y
-            JOIN model_year_engine mye ON y.id = mye.year_id
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
+            JOIN model_year_engine mye ON y.id_year = mye.year_id
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
             WHERE 1=1
         """
-        params: list = []
+        params: dict = {}
         if brand:
-            sql += " AND UPPER(b.name) = UPPER(?)"
-            params.append(brand)
+            sql += " AND b.name_brand ILIKE :brand"
+            params["brand"] = brand
         if model:
-            sql += " AND UPPER(m.name) = UPPER(?)"
-            params.append(model)
-        sql += " ORDER BY y.year DESC"
-        return self._query(sql, tuple(params))
+            sql += " AND m.name_model ILIKE :model"
+            params["model"] = model
+        sql += " ORDER BY y.year_car DESC"
+        return self._query(sql, params)
 
     def get_engines(
         self,
@@ -129,32 +143,33 @@ class Database:
     ) -> list[dict]:
         """Return engines, optionally filtered by brand/model/year."""
         sql = """
-            SELECT MIN(e.id) AS id, e.name,
+            SELECT MIN(e.id_engine) AS id, e.name_engine AS name,
                    MAX(e.displacement_cc) AS displacement_cc,
                    MAX(e.cylinders) AS cylinders,
-                   MAX(e.fuel_type) AS fuel_type,
+                   MAX(ft.name_fuel) AS fuel_type,
                    MAX(e.power_hp) AS power_hp,
                    MAX(e.torque_nm) AS torque_nm,
                    MAX(e.engine_code) AS engine_code
             FROM engines e
-            JOIN model_year_engine mye ON e.id = mye.engine_id
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-            JOIN years y ON mye.year_id = y.id
+            LEFT JOIN fuel_type ft ON e.id_fuel = ft.id_fuel
+            JOIN model_year_engine mye ON e.id_engine = mye.engine_id
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+            JOIN years y ON mye.year_id = y.id_year
             WHERE 1=1
         """
-        params: list = []
+        params: dict = {}
         if brand:
-            sql += " AND UPPER(b.name) = UPPER(?)"
-            params.append(brand)
+            sql += " AND b.name_brand ILIKE :brand"
+            params["brand"] = brand
         if model:
-            sql += " AND UPPER(m.name) = UPPER(?)"
-            params.append(model)
+            sql += " AND m.name_model ILIKE :model"
+            params["model"] = model
         if year:
-            sql += " AND y.year = ?"
-            params.append(int(year))
-        sql += " GROUP BY UPPER(e.name) ORDER BY e.name"
-        return self._query(sql, tuple(params))
+            sql += " AND y.year_car = :year"
+            params["year"] = int(year)
+        sql += " GROUP BY UPPER(e.name_engine), e.name_engine ORDER BY e.name_engine"
+        return self._query(sql, params)
 
     def get_model_year_engine(
         self,
@@ -166,30 +181,32 @@ class Database:
         """Return model_year_engine records for a specific vehicle config."""
         sql = """
             SELECT
-                mye.id,
-                b.name AS brand,
-                m.name AS model,
-                y.year,
-                e.id AS engine_id,
-                e.name AS engine,
+                mye.id_mye AS id,
+                b.name_brand AS brand,
+                m.name_model AS model,
+                y.year_car AS year,
+                e.id_engine AS engine_id,
+                e.name_engine AS engine,
                 mye.trim_level,
-                mye.drivetrain,
-                mye.transmission
+                dt.name_drivetrain AS drivetrain,
+                tr.name_transmission AS transmission
             FROM model_year_engine mye
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-            JOIN years y ON mye.year_id = y.id
-            JOIN engines e ON mye.engine_id = e.id
-            WHERE UPPER(b.name) = UPPER(?)
-              AND UPPER(m.name) = UPPER(?)
-              AND y.year = ?
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+            JOIN years y ON mye.year_id = y.id_year
+            JOIN engines e ON mye.engine_id = e.id_engine
+            LEFT JOIN drivetrain dt ON mye.id_drivetrain = dt.id_drivetrain
+            LEFT JOIN transmission tr ON mye.id_transmission = tr.id_transmission
+            WHERE b.name_brand ILIKE :brand
+              AND m.name_model ILIKE :model
+              AND y.year_car = :year
         """
-        params: list = [brand, model, int(year)]
+        params: dict = {"brand": brand, "model": model, "year": int(year)}
         if engine_id:
-            sql += " AND e.id = ?"
-            params.append(engine_id)
-        sql += " ORDER BY e.name, mye.trim_level"
-        return self._query(sql, tuple(params))
+            sql += " AND e.id_engine = :engine_id"
+            params["engine_id"] = engine_id
+        sql += " ORDER BY e.name_engine, mye.trim_level"
+        return self._query(sql, params)
 
     # ==================================================================
     # Parts catalog
@@ -200,9 +217,10 @@ class Database:
         return self._query_cached(
             "categories",
             """
-            SELECT id, name, name_es, slug, icon_name, display_order
+            SELECT id_part_category AS id, name_part_category AS name,
+                   name_es, slug, icon_name, display_order
             FROM part_categories
-            ORDER BY display_order, name
+            ORDER BY display_order, name_part_category
             """,
         )
 
@@ -210,12 +228,13 @@ class Database:
         """Return part groups for a given category."""
         return self._query(
             """
-            SELECT id, name, name_es, slug, display_order
+            SELECT id_part_group AS id, name_part_group AS name,
+                   name_es, slug, display_order
             FROM part_groups
-            WHERE category_id = ?
-            ORDER BY display_order, name
+            WHERE category_id = :cat_id
+            ORDER BY display_order, name_part_group
             """,
-            (category_id,),
+            {"cat_id": category_id},
         )
 
     def get_parts(
@@ -231,64 +250,64 @@ class Database:
 
         sql = """
             SELECT
-                p.id,
+                p.id_part AS id,
                 p.oem_part_number,
-                p.name,
+                p.name_part AS name,
                 p.name_es,
                 p.group_id,
-                pg.name AS group_name,
-                pc.name AS category_name
+                pg.name_part_group AS group_name,
+                pc.name_part_category AS category_name
             FROM parts p
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
         """
         where_parts: list[str] = []
-        params: list = []
+        params: dict = {}
 
         if group_id:
-            where_parts.append("p.group_id = ?")
-            params.append(group_id)
+            where_parts.append("p.group_id = :group_id")
+            params["group_id"] = group_id
         if mye_id:
             where_parts.append(
-                "p.id IN (SELECT part_id FROM vehicle_parts WHERE model_year_engine_id = ?)"
+                "p.id_part IN (SELECT part_id FROM vehicle_parts WHERE model_year_engine_id = :mye_id)"
             )
-            params.append(mye_id)
+            params["mye_id"] = mye_id
 
         if where_parts:
             sql += " WHERE " + " AND ".join(where_parts)
 
-        sql += " ORDER BY p.name LIMIT ? OFFSET ?"
-        params.extend([per_page, offset])
+        sql += " ORDER BY p.name_part LIMIT :limit OFFSET :offset"
+        params["limit"] = per_page
+        params["offset"] = offset
 
-        return self._query(sql, tuple(params))
+        return self._query(sql, params)
 
     def get_part(self, part_id: int) -> Optional[dict]:
         """Return a single part with group/category info, or None."""
         return self._query(
             """
             SELECT
-                p.id,
+                p.id_part AS id,
                 p.oem_part_number,
-                p.name,
+                p.name_part AS name,
                 p.name_es,
                 p.description,
                 p.description_es,
                 p.weight_kg,
-                p.material,
-                p.is_discontinued,
-                p.superseded_by_id,
+                mat.name_material AS material,
                 p.group_id,
-                pg.name AS group_name,
+                pg.name_part_group AS group_name,
                 pg.name_es AS group_name_es,
-                pc.id AS category_id,
-                pc.name AS category_name,
+                pc.id_part_category AS category_id,
+                pc.name_part_category AS category_name,
                 pc.name_es AS category_name_es
             FROM parts p
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE p.id = ?
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            LEFT JOIN materials mat ON p.id_material = mat.id_material
+            WHERE p.id_part = :part_id
             """,
-            (part_id,),
+            {"part_id": part_id},
             one=True,
         )
 
@@ -297,34 +316,37 @@ class Database:
         return self._query(
             """
             SELECT
-                ap.id,
+                ap.id_aftermarket_parts AS id,
                 ap.part_number,
-                ap.name,
+                ap.name_aftermarket_parts AS name,
                 ap.name_es,
-                m.name AS manufacturer_name,
+                m.name_manufacture AS manufacturer_name,
                 ap.manufacturer_id,
-                ap.quality_tier,
+                qt.name_quality AS quality_tier,
                 ap.price_usd,
-                ap.warranty_months,
-                ap.in_stock
+                ap.warranty_months
             FROM aftermarket_parts ap
-            JOIN manufacturers m ON ap.manufacturer_id = m.id
-            WHERE ap.oem_part_id = ?
-            ORDER BY ap.quality_tier DESC, ap.price_usd ASC
+            JOIN manufacturers m ON ap.manufacturer_id = m.id_manufacture
+            LEFT JOIN quality_tier qt ON ap.id_quality_tier = qt.id_quality_tier
+            WHERE ap.oem_part_id = :part_id
+            ORDER BY qt.name_quality DESC, ap.price_usd ASC
             """,
-            (part_id,),
+            {"part_id": part_id},
         )
 
     def get_cross_references(self, part_id: int) -> list[dict]:
         """Return cross-reference numbers for a part."""
         return self._query(
             """
-            SELECT id, cross_reference_number, reference_type, source, notes
-            FROM part_cross_references
-            WHERE part_id = ?
-            ORDER BY reference_type, cross_reference_number
+            SELECT id_part_cross_ref AS id, cross_reference_number,
+                   rt.name_ref_type AS reference_type,
+                   source_ref AS source, notes
+            FROM part_cross_references pcr
+            LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type
+            WHERE pcr.part_id = :part_id
+            ORDER BY rt.name_ref_type, pcr.cross_reference_number
             """,
-            (part_id,),
+            {"part_id": part_id},
         )
 
     def get_vehicles_for_part(self, part_id: int) -> list[dict]:
@@ -332,24 +354,25 @@ class Database:
         return self._query(
             """
             SELECT
-                b.name AS brand,
-                m.name AS model,
-                y.year,
-                e.name AS engine,
+                b.name_brand AS brand,
+                m.name_model AS model,
+                y.year_car AS year,
+                e.name_engine AS engine,
                 mye.trim_level,
                 vp.quantity_required,
-                vp.position,
+                pp.name_position_part AS position,
                 vp.fitment_notes
             FROM vehicle_parts vp
-            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-            JOIN years y ON mye.year_id = y.id
-            JOIN engines e ON mye.engine_id = e.id
-            WHERE vp.part_id = ?
-            ORDER BY b.name, m.name, y.year
+            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id_mye
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+            JOIN years y ON mye.year_id = y.id_year
+            JOIN engines e ON mye.engine_id = e.id_engine
+            LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+            WHERE vp.part_id = :part_id
+            ORDER BY b.name_brand, m.name_model, y.year_car
             """,
-            (part_id,),
+            {"part_id": part_id},
         )
 
     # ==================================================================
@@ -359,150 +382,93 @@ class Database:
     def search_parts(
         self, query: str, page: int = 1, per_page: int = 15
     ) -> list[dict]:
-        """Full-text search using FTS5, with fallback to LIKE."""
+        """Full-text search using PostgreSQL tsvector."""
         per_page = min(per_page, 100)
         offset = (page - 1) * per_page
 
-        conn = self._connect()
-        cursor = conn.cursor()
-
-        # Check if FTS5 table exists
-        cursor.execute(
-            "SELECT name FROM sqlite_master "
-            "WHERE type='table' AND name='parts_fts'"
+        return self._query(
+            """
+            SELECT
+                p.id_part AS id,
+                p.oem_part_number,
+                p.name_part AS name,
+                p.name_es,
+                p.description,
+                pg.name_part_group AS group_name,
+                pc.name_part_category AS category_name,
+                ts_rank(p.search_vector, plainto_tsquery('spanish', :q)) AS rank
+            FROM parts p
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE p.search_vector @@ plainto_tsquery('spanish', :q)
+            ORDER BY rank DESC
+            LIMIT :limit OFFSET :offset
+            """,
+            {"q": query, "limit": per_page, "offset": offset},
         )
-        fts_exists = cursor.fetchone() is not None
-
-        if fts_exists:
-            # Escape FTS5 special chars by quoting each term
-            terms = query.split()
-            quoted = ['"' + t.replace('"', '""') + '"' for t in terms]
-            fts_query = " ".join(quoted)
-
-            cursor.execute(
-                """
-                SELECT
-                    p.id,
-                    p.oem_part_number,
-                    p.name,
-                    p.name_es,
-                    p.description,
-                    pg.name AS group_name,
-                    pc.name AS category_name,
-                    bm25(parts_fts) AS rank
-                FROM parts_fts
-                JOIN parts p ON parts_fts.rowid = p.id
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE parts_fts MATCH ?
-                ORDER BY rank
-                LIMIT ? OFFSET ?
-                """,
-                (fts_query, per_page, offset),
-            )
-        else:
-            search_term = f"%{query}%"
-            cursor.execute(
-                """
-                SELECT
-                    p.id,
-                    p.oem_part_number,
-                    p.name,
-                    p.name_es,
-                    p.description,
-                    pg.name AS group_name,
-                    pc.name AS category_name,
-                    0 AS rank
-                FROM parts p
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE p.name LIKE ? OR p.name_es LIKE ?
-                   OR p.oem_part_number LIKE ? OR p.description LIKE ?
-                ORDER BY p.name
-                LIMIT ? OFFSET ?
-                """,
-                (
-                    search_term,
-                    search_term,
-                    search_term,
-                    search_term,
-                    per_page,
-                    offset,
-                ),
-            )
-
-        return [dict(r) for r in cursor.fetchall()]
 
     def search_part_number(self, number: str) -> list[dict]:
         """Search OEM, aftermarket, and cross-reference part numbers."""
-        search_term = f"%{number}%"
         results: list[dict] = []
-
-        conn = self._connect()
-        cursor = conn.cursor()
+        search_term = f"%{number}%"
 
         # OEM parts
-        cursor.execute(
+        rows = self._query(
             """
-            SELECT id, oem_part_number, name, name_es
+            SELECT id_part AS id, oem_part_number, name_part AS name, name_es
             FROM parts
-            WHERE oem_part_number LIKE ?
+            WHERE oem_part_number ILIKE :term
             """,
-            (search_term,),
+            {"term": search_term},
         )
-        for row in cursor.fetchall():
-            results.append(
-                {
-                    **dict(row),
-                    "match_type": "oem",
-                    "matched_number": row["oem_part_number"],
-                }
-            )
+        for row in rows:
+            results.append({
+                **row,
+                "match_type": "oem",
+                "matched_number": row["oem_part_number"],
+            })
 
         # Aftermarket parts
-        cursor.execute(
+        rows = self._query(
             """
-            SELECT p.id, p.oem_part_number, p.name, p.name_es, ap.part_number
+            SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name,
+                   p.name_es, ap.part_number
             FROM aftermarket_parts ap
-            JOIN parts p ON ap.oem_part_id = p.id
-            WHERE ap.part_number LIKE ?
+            JOIN parts p ON ap.oem_part_id = p.id_part
+            WHERE ap.part_number ILIKE :term
             """,
-            (search_term,),
+            {"term": search_term},
         )
-        for row in cursor.fetchall():
-            results.append(
-                {
-                    "id": row["id"],
-                    "oem_part_number": row["oem_part_number"],
-                    "name": row["name"],
-                    "name_es": row["name_es"],
-                    "match_type": "aftermarket",
-                    "matched_number": row["part_number"],
-                }
-            )
+        for row in rows:
+            results.append({
+                "id": row["id"],
+                "oem_part_number": row["oem_part_number"],
+                "name": row["name"],
+                "name_es": row["name_es"],
+                "match_type": "aftermarket",
+                "matched_number": row["part_number"],
+            })
 
         # Cross-references
-        cursor.execute(
+        rows = self._query(
             """
-            SELECT p.id, p.oem_part_number, p.name, p.name_es,
-                   pcr.cross_reference_number
+            SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name,
+                   p.name_es, pcr.cross_reference_number
             FROM part_cross_references pcr
-            JOIN parts p ON pcr.part_id = p.id
-            WHERE pcr.cross_reference_number LIKE ?
+            JOIN parts p ON pcr.part_id = p.id_part
+            WHERE pcr.cross_reference_number ILIKE :term
             """,
-            (search_term,),
+            {"term": search_term},
         )
-        for row in cursor.fetchall():
-            results.append(
-                {
-                    "id": row["id"],
-                    "oem_part_number": row["oem_part_number"],
-                    "name": row["name"],
-                    "name_es": row["name_es"],
-                    "match_type": "cross_reference",
-                    "matched_number": row["cross_reference_number"],
-                }
-            )
+        for row in rows:
+            results.append({
+                "id": row["id"],
+                "oem_part_number": row["oem_part_number"],
+                "name": row["name"],
+                "name_es": row["name_es"],
+                "match_type": "cross_reference",
+                "matched_number": row["cross_reference_number"],
+            })
 
         return results
 
@@ -519,9 +485,9 @@ class Database:
                 engine_info, body_class, drive_type,
                 model_year_engine_id, created_at, expires_at
             FROM vin_cache
-            WHERE vin = ? AND expires_at > datetime('now')
+            WHERE vin = :vin AND expires_at > NOW()
             """,
-            (vin.upper().strip(),),
+            {"vin": vin.upper().strip()},
             one=True,
         )
 
@@ -535,33 +501,40 @@ class Database:
         engine_info: str,
         body_class: str,
         drive_type: str,
-    ) -> int:
-        """Insert or replace a VIN cache entry (30-day expiry)."""
+    ) -> Optional[int]:
+        """Insert or update a VIN cache entry (30-day expiry)."""
         expires = datetime.utcnow() + timedelta(days=30)
-        conn = self._connect()
-        cursor = conn.cursor()
-        cursor.execute(
+        decoded = json_module.loads(data) if isinstance(data, str) else data
+        return self._execute(
             """
-            INSERT OR REPLACE INTO vin_cache
+            INSERT INTO vin_cache
                 (vin, decoded_data, make, model, year,
                  engine_info, body_class, drive_type, expires_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            VALUES (:vin, :decoded_data, :make, :model, :year,
+                    :engine_info, :body_class, :drive_type, :expires_at)
+            ON CONFLICT (vin) DO UPDATE SET
+                decoded_data = EXCLUDED.decoded_data,
+                make = EXCLUDED.make,
+                model = EXCLUDED.model,
+                year = EXCLUDED.year,
+                engine_info = EXCLUDED.engine_info,
+                body_class = EXCLUDED.body_class,
+                drive_type = EXCLUDED.drive_type,
+                expires_at = EXCLUDED.expires_at
+            RETURNING id
             """,
-            (
-                vin.upper().strip(),
-                data,
-                make,
-                model,
-                year,
-                engine_info,
-                body_class,
-                drive_type,
-                expires.isoformat(),
-            ),
+            {
+                "vin": vin.upper().strip(),
+                "decoded_data": json_module.dumps(decoded),
+                "make": make,
+                "model": model,
+                "year": year,
+                "engine_info": engine_info,
+                "body_class": body_class,
+                "drive_type": drive_type,
+                "expires_at": expires.isoformat(),
+            },
         )
-        conn.commit()
-        self._cache.clear()
-        return cursor.lastrowid
 
     # ==================================================================
     # Stats
@@ -569,44 +542,43 @@ class Database:
 
     def get_stats(self) -> dict:
         """Return counts for all major tables plus top brands by fitment."""
-        conn = self._connect()
-        cursor = conn.cursor()
-        stats: dict = {}
+        session = self._session()
+        try:
+            stats: dict = {}
+            table_map = {
+                "brands": "brands",
+                "models": "models",
+                "years": "years",
+                "engines": "engines",
+                "part_categories": "part_categories",
+                "part_groups": "part_groups",
+                "parts": "parts",
+                "aftermarket_parts": "aftermarket_parts",
+                "manufacturers": "manufacturers",
+                "vehicle_parts": "vehicle_parts",
+                "part_cross_references": "part_cross_references",
+            }
+            for key, table in table_map.items():
+                row = session.execute(text(f"SELECT COUNT(*) AS cnt FROM {table}")).mappings().one()
+                stats[key] = row["cnt"]
 
-        for table in [
-            "brands",
-            "models",
-            "years",
-            "engines",
-            "part_categories",
-            "part_groups",
-            "parts",
-            "aftermarket_parts",
-            "manufacturers",
-            "vehicle_parts",
-            "part_cross_references",
-        ]:
-            cursor.execute(f"SELECT COUNT(*) FROM {table}")
-            stats[table] = cursor.fetchone()[0]
-
-        # Top brands by number of fitments
-        cursor.execute(
-            """
-            SELECT b.name, COUNT(DISTINCT vp.id) AS cnt
-            FROM brands b
-            JOIN models m ON m.brand_id = b.id
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN vehicle_parts vp ON vp.model_year_engine_id = mye.id
-            GROUP BY b.name
-            ORDER BY cnt DESC
-            LIMIT 10
-            """
-        )
-        stats["top_brands"] = [
-            {"name": r["name"], "count": r["cnt"]} for r in cursor.fetchall()
-        ]
-
-        return stats
+            # Top brands by number of fitments
+            rows = session.execute(text("""
+                SELECT b.name_brand AS name, COUNT(DISTINCT vp.id_vehicle_part) AS cnt
+                FROM brands b
+                JOIN models m ON m.brand_id = b.id_brand
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                JOIN vehicle_parts vp ON vp.model_year_engine_id = mye.id_mye
+                GROUP BY b.name_brand
+                ORDER BY cnt DESC
+                LIMIT 10
+            """)).mappings().all()
+            stats["top_brands"] = [
+                {"name": r["name"], "count": r["cnt"]} for r in rows
+            ]
+            return stats
+        finally:
+            session.close()
 
     # ==================================================================
     # Admin — Manufacturers
@@ -616,27 +588,40 @@ class Database:
         """Return all manufacturers ordered by name."""
         return self._query(
             """
-            SELECT id, name, type, quality_tier, country, logo_url, website
-            FROM manufacturers
-            ORDER BY name
+            SELECT m.id_manufacture AS id, m.name_manufacture AS name,
+                   mt.name_type_manu AS type,
+                   qt.name_quality AS quality_tier,
+                   c.name_country AS country,
+                   m.logo_url, m.website
+            FROM manufacturers m
+            LEFT JOIN manufacture_type mt ON m.id_type_manu = mt.id_type_manu
+            LEFT JOIN quality_tier qt ON m.id_quality_tier = qt.id_quality_tier
+            LEFT JOIN countries c ON m.id_country = c.id_country
+            ORDER BY m.name_manufacture
             """
         )
 
-    def create_manufacturer(self, data: dict) -> int:
+    def create_manufacturer(self, data: dict) -> Optional[int]:
         """Insert a new manufacturer and return its id."""
         return self._execute(
             """
-            INSERT INTO manufacturers (name, type, quality_tier, country, logo_url, website)
-            VALUES (?, ?, ?, ?, ?, ?)
+            INSERT INTO manufacturers (name_manufacture, id_type_manu, id_quality_tier,
+                                       id_country, logo_url, website)
+            VALUES (:name,
+                    (SELECT id_type_manu FROM manufacture_type WHERE name_type_manu = :type),
+                    (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :quality_tier),
+                    (SELECT id_country FROM countries WHERE name_country = :country),
+                    :logo_url, :website)
+            RETURNING id_manufacture
             """,
-            (
-                data["name"],
-                data.get("type"),
-                data.get("quality_tier"),
-                data.get("country"),
-                data.get("logo_url"),
-                data.get("website"),
-            ),
+            {
+                "name": data["name"],
+                "type": data.get("type"),
+                "quality_tier": data.get("quality_tier"),
+                "country": data.get("country"),
+                "logo_url": data.get("logo_url"),
+                "website": data.get("website"),
+            },
         )
 
     def update_manufacturer(self, mfr_id: int, data: dict) -> None:
@@ -644,47 +629,55 @@ class Database:
         self._execute(
             """
             UPDATE manufacturers
-            SET name = ?, type = ?, quality_tier = ?, country = ?, logo_url = ?, website = ?
-            WHERE id = ?
+            SET name_manufacture = :name,
+                id_type_manu = (SELECT id_type_manu FROM manufacture_type WHERE name_type_manu = :type),
+                id_quality_tier = (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :quality_tier),
+                id_country = (SELECT id_country FROM countries WHERE name_country = :country),
+                logo_url = :logo_url, website = :website
+            WHERE id_manufacture = :mfr_id
             """,
-            (
-                data["name"],
-                data.get("type"),
-                data.get("quality_tier"),
-                data.get("country"),
-                data.get("logo_url"),
-                data.get("website"),
-                mfr_id,
-            ),
+            {
+                "name": data["name"],
+                "type": data.get("type"),
+                "quality_tier": data.get("quality_tier"),
+                "country": data.get("country"),
+                "logo_url": data.get("logo_url"),
+                "website": data.get("website"),
+                "mfr_id": mfr_id,
+            },
         )
 
     def delete_manufacturer(self, mfr_id: int) -> None:
         """Delete a manufacturer by id."""
-        self._execute("DELETE FROM manufacturers WHERE id = ?", (mfr_id,))
+        self._execute("DELETE FROM manufacturers WHERE id_manufacture = :id", {"id": mfr_id})
 
     # ==================================================================
     # Admin — Parts
     # ==================================================================
 
-    def create_part(self, data: dict) -> int:
+    def create_part(self, data: dict) -> Optional[int]:
         """Insert a new part and return its id."""
         return self._execute(
             """
             INSERT INTO parts
-                (oem_part_number, name, name_es, group_id,
-                 description, description_es, weight_kg, material)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                (oem_part_number, name_part, name_es, group_id,
+                 description, description_es, weight_kg,
+                 id_material)
+            VALUES (:oem_part_number, :name, :name_es, :group_id,
+                    :description, :description_es, :weight_kg,
+                    (SELECT id_material FROM materials WHERE name_material = :material))
+            RETURNING id_part
             """,
-            (
-                data["oem_part_number"],
-                data["name"],
-                data.get("name_es"),
-                data.get("group_id"),
-                data.get("description"),
-                data.get("description_es"),
-                data.get("weight_kg"),
-                data.get("material"),
-            ),
+            {
+                "oem_part_number": data["oem_part_number"],
+                "name": data["name"],
+                "name_es": data.get("name_es"),
+                "group_id": data.get("group_id"),
+                "description": data.get("description"),
+                "description_es": data.get("description_es"),
+                "weight_kg": data.get("weight_kg"),
+                "material": data.get("material"),
+            },
         )
 
     def update_part(self, part_id: int, data: dict) -> None:
@@ -692,46 +685,52 @@ class Database:
         self._execute(
             """
             UPDATE parts
-            SET oem_part_number = ?, name = ?, name_es = ?, group_id = ?,
-                description = ?, description_es = ?, weight_kg = ?, material = ?
-            WHERE id = ?
+            SET oem_part_number = :oem_part_number, name_part = :name,
+                name_es = :name_es, group_id = :group_id,
+                description = :description, description_es = :description_es,
+                weight_kg = :weight_kg,
+                id_material = (SELECT id_material FROM materials WHERE name_material = :material)
+            WHERE id_part = :part_id
             """,
-            (
-                data["oem_part_number"],
-                data["name"],
-                data.get("name_es"),
-                data.get("group_id"),
-                data.get("description"),
-                data.get("description_es"),
-                data.get("weight_kg"),
-                data.get("material"),
-                part_id,
-            ),
+            {
+                "oem_part_number": data["oem_part_number"],
+                "name": data["name"],
+                "name_es": data.get("name_es"),
+                "group_id": data.get("group_id"),
+                "description": data.get("description"),
+                "description_es": data.get("description_es"),
+                "weight_kg": data.get("weight_kg"),
+                "material": data.get("material"),
+                "part_id": part_id,
+            },
         )
 
     def delete_part(self, part_id: int) -> None:
         """Delete a part by id."""
-        self._execute("DELETE FROM parts WHERE id = ?", (part_id,))
+        self._execute("DELETE FROM parts WHERE id_part = :id", {"id": part_id})
 
     # ==================================================================
     # Admin — Cross-references
     # ==================================================================
 
-    def create_crossref(self, data: dict) -> int:
+    def create_crossref(self, data: dict) -> Optional[int]:
         """Insert a new cross-reference and return its id."""
         return self._execute(
             """
             INSERT INTO part_cross_references
-                (part_id, cross_reference_number, reference_type, source, notes)
-            VALUES (?, ?, ?, ?, ?)
+                (part_id, cross_reference_number, id_ref_type, source_ref, notes)
+            VALUES (:part_id, :cross_reference_number,
+                    (SELECT id_ref_type FROM reference_type WHERE name_ref_type = :reference_type),
+                    :source, :notes)
+            RETURNING id_part_cross_ref
             """,
-            (
-                data["part_id"],
-                data["cross_reference_number"],
-                data.get("reference_type"),
-                data.get("source"),
-                data.get("notes"),
-            ),
+            {
+                "part_id": data["part_id"],
+                "cross_reference_number": data["cross_reference_number"],
+                "reference_type": data.get("reference_type"),
+                "source": data.get("source"),
+                "notes": data.get("notes"),
+            },
         )
 
     def update_crossref(self, xref_id: int, data: dict) -> None:
@@ -739,24 +738,25 @@ class Database:
         self._execute(
             """
             UPDATE part_cross_references
-            SET part_id = ?, cross_reference_number = ?,
-                reference_type = ?, source = ?, notes = ?
-            WHERE id = ?
+            SET part_id = :part_id, cross_reference_number = :cross_reference_number,
+                id_ref_type = (SELECT id_ref_type FROM reference_type WHERE name_ref_type = :reference_type),
+                source_ref = :source, notes = :notes
+            WHERE id_part_cross_ref = :xref_id
             """,
-            (
-                data["part_id"],
-                data["cross_reference_number"],
-                data.get("reference_type"),
-                data.get("source"),
-                data.get("notes"),
-                xref_id,
-            ),
+            {
+                "part_id": data["part_id"],
+                "cross_reference_number": data["cross_reference_number"],
+                "reference_type": data.get("reference_type"),
+                "source": data.get("source"),
+                "notes": data.get("notes"),
+                "xref_id": xref_id,
+            },
         )
 
     def delete_crossref(self, xref_id: int) -> None:
         """Delete a cross-reference by id."""
         self._execute(
-            "DELETE FROM part_cross_references WHERE id = ?", (xref_id,)
+            "DELETE FROM part_cross_references WHERE id_part_cross_ref = :id", {"id": xref_id}
         )
 
     def get_crossrefs_paginated(
@@ -768,18 +768,19 @@ class Database:
         return self._query(
             """
             SELECT
-                pcr.id,
+                pcr.id_part_cross_ref AS id,
                 pcr.part_id,
                 pcr.cross_reference_number,
-                pcr.reference_type,
-                pcr.source,
+                rt.name_ref_type AS reference_type,
+                pcr.source_ref AS source,
                 pcr.notes,
                 p.oem_part_number,
-                p.name AS part_name
+                p.name_part AS part_name
             FROM part_cross_references pcr
-            JOIN parts p ON pcr.part_id = p.id
-            ORDER BY pcr.id
-            LIMIT ? OFFSET ?
+            JOIN parts p ON pcr.part_id = p.id_part
+            LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type
+            ORDER BY pcr.id_part_cross_ref
+            LIMIT :limit OFFSET :offset
             """,
-            (per_page, offset),
+            {"limit": per_page, "offset": offset},
         )
diff --git a/console/main.py b/console/main.py
index 055a6c0..eb2b58f 100644
--- a/console/main.py
+++ b/console/main.py
@@ -1,5 +1,5 @@
 """
-Entry point for the AUTOPARTES Pick/VT220-style console application.
+Entry point for the NEXUS AUTOPARTS Pick/VT220-style console application.
 
 Usage:
     python -m console              # via package
diff --git a/console/renderers/base.py b/console/renderers/base.py
index c879776..bc1e6c0 100644
--- a/console/renderers/base.py
+++ b/console/renderers/base.py
@@ -1,5 +1,5 @@
 """
-Abstract base renderer interface for the AUTOPARTES console application.
+Abstract base renderer interface for the NEXUS AUTOPARTS console application.
 
 Every renderer (curses VT220, Textual/Rich, etc.) must subclass
 :class:`BaseRenderer` and implement all of its methods.  Screens call
diff --git a/console/renderers/curses_renderer.py b/console/renderers/curses_renderer.py
index d62699b..ea4fcc7 100644
--- a/console/renderers/curses_renderer.py
+++ b/console/renderers/curses_renderer.py
@@ -1,5 +1,5 @@
 """
-Curses-based VT220 renderer for the AUTOPARTES console application.
+Curses-based VT220 renderer for the NEXUS AUTOPARTS console application.
 
 Implements :class:`BaseRenderer` with a green-on-black aesthetic inspired
 by classic Pick/UNIX VT220 terminals.  All drawing is done through Python's
diff --git a/console/screens/admin_crossref.py b/console/screens/admin_crossref.py
index f3e801e..bcde6be 100644
--- a/console/screens/admin_crossref.py
+++ b/console/screens/admin_crossref.py
@@ -1,5 +1,5 @@
 """
-Admin CRUD screen for Cross-References in the AUTOPARTES console application.
+Admin CRUD screen for Cross-References in the NEXUS AUTOPARTS console application.
 
 Provides a paginated list view with create (F3), edit (ENTER), and
 delete (F8/Del) operations for the part_cross_references table.
diff --git a/console/screens/admin_fabricantes.py b/console/screens/admin_fabricantes.py
index 2c3167d..8fd039f 100644
--- a/console/screens/admin_fabricantes.py
+++ b/console/screens/admin_fabricantes.py
@@ -1,5 +1,5 @@
 """
-Admin CRUD screen for Manufacturers in the AUTOPARTES console application.
+Admin CRUD screen for Manufacturers in the NEXUS AUTOPARTS console application.
 
 Provides a list view with create (F3), edit (ENTER), and delete (F8/Del)
 operations for the manufacturers table.
diff --git a/console/screens/admin_import.py b/console/screens/admin_import.py
index 4326613..1562fad 100644
--- a/console/screens/admin_import.py
+++ b/console/screens/admin_import.py
@@ -1,5 +1,5 @@
 """
-Import/Export screen for the AUTOPARTES console application.
+Import/Export screen for the NEXUS AUTOPARTS console application.
 
 Provides a simple menu flow to import CSV files into the database or
 export data to JSON files.  Uses the renderer's show_input and
diff --git a/console/screens/admin_partes.py b/console/screens/admin_partes.py
index 512fdaf..f34cdd3 100644
--- a/console/screens/admin_partes.py
+++ b/console/screens/admin_partes.py
@@ -1,5 +1,5 @@
 """
-Admin CRUD screen for Parts in the AUTOPARTES console application.
+Admin CRUD screen for Parts in the NEXUS AUTOPARTS console application.
 
 Provides a paginated list view with create (F3), edit (ENTER), and
 delete (F8/Del) operations.  Form editing is handled inline with
diff --git a/console/screens/buscar_parte.py b/console/screens/buscar_parte.py
index 782a5b3..5aa8e2a 100644
--- a/console/screens/buscar_parte.py
+++ b/console/screens/buscar_parte.py
@@ -1,5 +1,5 @@
 """
-Part number search screen for the AUTOPARTES console application.
+Part number search screen for the NEXUS AUTOPARTS console application.
 
 Prompts the user for a part number (OEM, aftermarket, or cross-reference)
 and displays matching results in a table.  Selecting a result navigates
diff --git a/console/screens/buscar_texto.py b/console/screens/buscar_texto.py
index 181c104..a32e903 100644
--- a/console/screens/buscar_texto.py
+++ b/console/screens/buscar_texto.py
@@ -1,5 +1,5 @@
 """
-Full-text search screen for the AUTOPARTES console application.
+Full-text search screen for the NEXUS AUTOPARTS console application.
 
 Prompts the user for a search query and displays matching parts using
 the FTS5 full-text search engine (with LIKE fallback).  Results are
diff --git a/console/screens/catalogo.py b/console/screens/catalogo.py
index 93fa923..7f327fe 100644
--- a/console/screens/catalogo.py
+++ b/console/screens/catalogo.py
@@ -1,5 +1,5 @@
 """
-Catalog navigation screen for the AUTOPARTES console application.
+Catalog navigation screen for the NEXUS AUTOPARTS console application.
 
 Provides a three-level drill-down through the parts hierarchy:
 Categories -> Groups -> Parts.  An optional vehicle filter (mye_id)
diff --git a/console/screens/comparador.py b/console/screens/comparador.py
index 7a004fb..2fea444 100644
--- a/console/screens/comparador.py
+++ b/console/screens/comparador.py
@@ -1,5 +1,5 @@
 """
-Part comparator screen for the AUTOPARTES console application.
+Part comparator screen for the NEXUS AUTOPARTS console application.
 
 Displays a side-by-side comparison of an OEM part against its aftermarket
 alternatives.  The first column is always the OEM part; subsequent columns
diff --git a/console/screens/estadisticas.py b/console/screens/estadisticas.py
index c8dd997..13ad9ef 100644
--- a/console/screens/estadisticas.py
+++ b/console/screens/estadisticas.py
@@ -1,5 +1,5 @@
 """
-Statistics dashboard screen for the AUTOPARTES console application.
+Statistics dashboard screen for the NEXUS AUTOPARTS console application.
 
 Displays database table counts and coverage metrics retrieved via
 :meth:`Database.get_stats`.
diff --git a/console/screens/menu_principal.py b/console/screens/menu_principal.py
index 7c89ccd..750ac58 100644
--- a/console/screens/menu_principal.py
+++ b/console/screens/menu_principal.py
@@ -1,5 +1,5 @@
 """
-Main menu screen for the AUTOPARTES console application.
+Main menu screen for the NEXUS AUTOPARTS console application.
 
 Displays a numbered Pick-style menu with navigation options for all
 application sections.  Number keys jump directly; arrow keys move the
diff --git a/console/screens/parte_detalle.py b/console/screens/parte_detalle.py
index 3f84802..b0c1457 100644
--- a/console/screens/parte_detalle.py
+++ b/console/screens/parte_detalle.py
@@ -1,5 +1,5 @@
 """
-Part detail screen for the AUTOPARTES console application.
+Part detail screen for the NEXUS AUTOPARTS console application.
 
 Shows full part information (OEM number, name, group, category, etc.)
 with a table of aftermarket alternatives.  Number keys navigate to
diff --git a/console/screens/vehiculo_nav.py b/console/screens/vehiculo_nav.py
index b46bea8..0700c1e 100644
--- a/console/screens/vehiculo_nav.py
+++ b/console/screens/vehiculo_nav.py
@@ -1,5 +1,5 @@
 """
-Vehicle drill-down navigation screen for the AUTOPARTES console application.
+Vehicle drill-down navigation screen for the NEXUS AUTOPARTS console application.
 
 Guides the user through a four-level hierarchy:
 
diff --git a/console/screens/vin_decoder.py b/console/screens/vin_decoder.py
index 3fe882a..acaf22f 100644
--- a/console/screens/vin_decoder.py
+++ b/console/screens/vin_decoder.py
@@ -1,5 +1,5 @@
 """
-VIN decoder screen for the AUTOPARTES console application.
+VIN decoder screen for the NEXUS AUTOPARTS console application.
 
 Prompts for a 17-character Vehicle Identification Number, decodes it
 via the NHTSA vPIC API (with local caching), and displays the decoded
diff --git a/console/tests/test_integration.py b/console/tests/test_integration.py
index 51206c0..f6bb92b 100644
--- a/console/tests/test_integration.py
+++ b/console/tests/test_integration.py
@@ -1,5 +1,5 @@
 """
-Integration tests for the AUTOPARTES console application.
+Integration tests for the NEXUS AUTOPARTS console application.
 
 Uses a MockRenderer that records draw calls instead of painting to a real
 terminal, allowing end-to-end testing of the screen -> renderer pipeline
diff --git a/console/utils/formatting.py b/console/utils/formatting.py
index b14bdb4..1482532 100644
--- a/console/utils/formatting.py
+++ b/console/utils/formatting.py
@@ -1,5 +1,5 @@
 """
-Display formatting utilities for the AUTOPARTES console application.
+Display formatting utilities for the NEXUS AUTOPARTS console application.
 
 Functions for currency, numbers, text truncation, table layout, and
 quality-tier visual bars.
diff --git a/console/utils/vin_api.py b/console/utils/vin_api.py
index afefb8e..7f92709 100644
--- a/console/utils/vin_api.py
+++ b/console/utils/vin_api.py
@@ -1,5 +1,5 @@
 """
-NHTSA VIN Decoder API client for the AUTOPARTES console application.
+NHTSA VIN Decoder API client for the NEXUS AUTOPARTS console application.
 
 Wraps the National Highway Traffic Safety Administration (NHTSA) Vehicle
 Product Information Catalog (vPIC) DecodeVin endpoint to retrieve vehicle
diff --git a/dashboard/admin.html b/dashboard/admin.html
index ea991bc..61f98eb 100644
--- a/dashboard/admin.html
+++ b/dashboard/admin.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Admin Panel - Autopartes DB</title>
+    <title>Admin Panel - Nexus Autoparts</title>
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Orbitron:wght@700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="/shared.css">
     <style>
diff --git a/dashboard/admin.js b/dashboard/admin.js
index 0902c9f..db18cec 100644
--- a/dashboard/admin.js
+++ b/dashboard/admin.js
@@ -1,6 +1,6 @@
 /**
  * Admin Panel JavaScript
- * CRUD operations and CSV import/export for Autopartes DB
+ * CRUD operations and CSV import/export for Nexus Autoparts
  */
 
 // State
diff --git a/dashboard/customer-landing.html b/dashboard/customer-landing.html
index 6f6c4db..65b7127 100644
--- a/dashboard/customer-landing.html
+++ b/dashboard/customer-landing.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AutoParts DB - Tienda de Autopartes</title>
+    <title>Nexus Autoparts - Tu conexión directa con las partes que necesitas</title>
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Orbitron:wght@400;500;600;700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="/shared.css">
     <style>
@@ -1095,7 +1095,7 @@
             <div class="footer-brand">
                 <div class="logo">
                     <div class="logo-icon">⚙️</div>
-                    <div class="logo-text">AUTOPARTS DB</div>
+                    <div class="logo-text">NEXUS AUTOPARTS</div>
                 </div>
                 <p>Sistema de catálogo de autopartes con navegación jerárquica, diagramas explosionados y decodificador de VIN.</p>
                 <div class="social-links">
@@ -1131,7 +1131,7 @@
             </div>
         </div>
         <div class="footer-bottom">
-            <p>© 2024 AutoParts DB. Sistema de Catálogo de Autopartes.</p>
+            <p>© 2026 Nexus Autoparts. Tu conexión directa con las partes que necesitas.</p>
             <p>Desarrollado con Flask + SQLite</p>
         </div>
     </footer>
diff --git a/dashboard/diagrams.html b/dashboard/diagrams.html
index 91f3329..d39580d 100644
--- a/dashboard/diagrams.html
+++ b/dashboard/diagrams.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Diagramas de Suspensión - AutoParts DB</title>
+    <title>Diagramas - Nexus Autoparts</title>
     <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🔧</text></svg>">
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Orbitron:wght@400;500;600;700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
diff --git a/dashboard/enhanced-search.js b/dashboard/enhanced-search.js
index 81e529f..0b47717 100644
--- a/dashboard/enhanced-search.js
+++ b/dashboard/enhanced-search.js
@@ -10,7 +10,7 @@ const enhancedSearch = {
         debounceMs: 300,
         maxResults: 8,
         maxRecent: 5,
-        storageKey: 'autopartes_recent_searches'
+        storageKey: 'nexus_recent_searches'
     },
 
     // State
diff --git a/dashboard/index.html b/dashboard/index.html
index b5517c4..eec1da6 100644
--- a/dashboard/index.html
+++ b/dashboard/index.html
@@ -3,7 +3,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Catálogo de Autopartes - AutoParts DB</title>
+    <title>Catálogo - Nexus Autoparts</title>
     <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>🔧</text></svg>">
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=Orbitron:wght@400;500;600;700&display=swap" rel="stylesheet">
     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
diff --git a/dashboard/nav.js b/dashboard/nav.js
index cff3845..e8afec1 100644
--- a/dashboard/nav.js
+++ b/dashboard/nav.js
@@ -1,5 +1,5 @@
 /**
- * nav.js  --  Shared navigation component for AutoParts DB
+ * nav.js  --  Shared navigation component for NEXUS AUTOPARTS
  *
  * Injects a consistent header/nav bar into <div id="shared-nav"></div>.
  * Auto-highlights the current page link based on window.location.pathname.
@@ -86,7 +86,7 @@
         +           '-webkit-background-clip: text;'
         +           '-webkit-text-fill-color: transparent;'
         +           'background-clip: text;'
-        +       '">AUTOPARTS DB</span>'
+        +       '">NEXUS AUTOPARTS</span>'
         +     '</a>'
         // Slot for extra page-specific content (search bars, stats, etc.)
         +     '<div id="shared-nav-extra" style="display: contents;"></div>'
diff --git a/dashboard/server.py b/dashboard/server.py
index e0ab121..ee801f4 100644
--- a/dashboard/server.py
+++ b/dashboard/server.py
@@ -1,3800 +1,2327 @@
-from flask import Flask, render_template, jsonify, request, send_from_directory
-import sqlite3
+from flask import Flask, jsonify, request, send_from_directory
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.exc import IntegrityError
 import os
+import sys
+import json as json_module
+import re
+import base64
+import uuid
+import urllib.request
+from datetime import datetime, timedelta
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..'))
+from config import DB_URL
 
 app = Flask(__name__, static_folder='.')
 
-# Database path - adjust as needed
-DATABASE_PATH = '../vehicle_database/vehicle_database.db'
+engine = create_engine(DB_URL, pool_pre_ping=True, pool_size=5, max_overflow=10)
+Session = sessionmaker(bind=engine)
 
-def get_db_connection():
-    """Get a connection to the vehicle database"""
-    conn = sqlite3.connect(DATABASE_PATH)
-    conn.row_factory = sqlite3.Row  # This enables column access by name
-    return conn
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
 
 def get_all_brands(detailed=False):
-    """Get all unique brands that have vehicles with parts"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    if detailed:
-        cursor.execute("""
-            SELECT b.name,
-                   COUNT(DISTINCT m.name) AS model_count,
-                   COUNT(DISTINCT mye.id) AS vehicle_count
-            FROM brands b
-            JOIN models m ON m.brand_id = b.id
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) vp
-              ON mye.id = vp.model_year_engine_id
-            GROUP BY b.name
-            ORDER BY b.name
-            LIMIT 500
-        """)
-        brands = [{'name': row['name'], 'model_count': row['model_count'],
-                    'vehicle_count': row['vehicle_count']} for row in cursor.fetchall()]
-    else:
-        cursor.execute("""
-            SELECT DISTINCT b.name
-            FROM brands b
-            JOIN models m ON m.brand_id = b.id
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) vp
-              ON mye.id = vp.model_year_engine_id
-            ORDER BY b.name
-            LIMIT 500
-        """)
-        brands = [row['name'] for row in cursor.fetchall()]
-    conn.close()
-    return brands
+    session = Session()
+    try:
+        if detailed:
+            sql = text("""
+                SELECT b.name_brand AS name,
+                       COUNT(DISTINCT m.name_model) AS model_count,
+                       COUNT(DISTINCT mye.id_mye) AS vehicle_count
+                FROM brands b
+                JOIN models m ON m.brand_id = b.id_brand
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                GROUP BY b.name_brand ORDER BY b.name_brand LIMIT 500
+            """)
+            rows = session.execute(sql).mappings().all()
+            return [{'name': r['name'], 'model_count': r['model_count'],
+                     'vehicle_count': r['vehicle_count']} for r in rows]
+        else:
+            sql = text("""
+                SELECT DISTINCT b.name_brand AS name
+                FROM brands b
+                JOIN models m ON m.brand_id = b.id_brand
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                ORDER BY b.name_brand LIMIT 500
+            """)
+            rows = session.execute(sql).mappings().all()
+            return [r['name'] for r in rows]
+    finally:
+        session.close()
+
 
 def get_all_years():
-    """Get all unique years from the database"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT DISTINCT year FROM years ORDER BY year DESC LIMIT 200")
-    years = [row['year'] for row in cursor.fetchall()]
-    conn.close()
-    return years
+    session = Session()
+    try:
+        rows = session.execute(text(
+            "SELECT DISTINCT year_car AS year FROM years ORDER BY year_car DESC LIMIT 200"
+        )).mappings().all()
+        return [r['year'] for r in rows]
+    finally:
+        session.close()
+
 
 def get_all_engines():
-    """Get all unique engines from the database"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("SELECT DISTINCT name FROM engines ORDER BY name LIMIT 5000")
-    engines = [row['name'] for row in cursor.fetchall()]
-    conn.close()
-    return engines
+    session = Session()
+    try:
+        rows = session.execute(text(
+            "SELECT DISTINCT name_engine AS name FROM engines ORDER BY name_engine LIMIT 5000"
+        )).mappings().all()
+        return [r['name'] for r in rows]
+    finally:
+        session.close()
+
 
 def get_models_by_brand(brand_name=None):
-    """Get all models that have vehicles with parts, optionally filtered by brand"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
+    session = Session()
+    try:
+        if brand_name:
+            sql = text("""
+                SELECT DISTINCT m.name_model AS name
+                FROM models m
+                JOIN brands b ON m.brand_id = b.id_brand
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                WHERE b.name_brand ILIKE :brand
+                ORDER BY m.name_model LIMIT 1000
+            """)
+            rows = session.execute(sql, {'brand': brand_name}).mappings().all()
+        else:
+            sql = text("""
+                SELECT DISTINCT m.name_model AS name
+                FROM models m
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                ORDER BY m.name_model LIMIT 1000
+            """)
+            rows = session.execute(sql).mappings().all()
+        return [r['name'] for r in rows]
+    finally:
+        session.close()
 
-    if brand_name:
-        cursor.execute("""
-            SELECT DISTINCT m.name
-            FROM models m
-            JOIN brands b ON m.brand_id = b.id
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN vehicle_parts vp ON vp.model_year_engine_id = mye.id
-            WHERE UPPER(b.name) = UPPER(?)
-            ORDER BY m.name
-            LIMIT 1000
-        """, (brand_name,))
-    else:
-        cursor.execute("""
-            SELECT DISTINCT m.name
-            FROM models m
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN vehicle_parts vp ON vp.model_year_engine_id = mye.id
-            ORDER BY m.name
-            LIMIT 1000
-        """)
 
-    models = [row['name'] for row in cursor.fetchall()]
-    conn.close()
-    return models
-
-def search_vehicles(brand=None, model=None, year=None, engine=None, with_parts=True, page=1, per_page=50):
-    """Search for vehicles based on filters. By default only returns vehicles with parts."""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    per_page = min(per_page, 100)
-    offset = (page - 1) * per_page
-
-    base_from = """
-        FROM model_year_engine mye
-        JOIN models m ON mye.model_id = m.id
-        JOIN brands b ON m.brand_id = b.id
-        JOIN years y ON mye.year_id = y.id
-        JOIN engines e ON mye.engine_id = e.id
-    """
-
-    # Only show vehicles that have parts — use JOIN instead of EXISTS for performance
-    if with_parts:
-        base_from += " JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) AS has_parts ON mye.id = has_parts.model_year_engine_id"
-        where = " WHERE 1=1"
-    else:
+def search_vehicles(brand=None, model=None, year=None, engine_name=None, with_parts=False, page=1, per_page=50):
+    session = Session()
+    try:
+        per_page = min(per_page, 100)
+        offset = (page - 1) * per_page
+        base_from = """
+            FROM model_year_engine mye
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+            JOIN years y ON mye.year_id = y.id_year
+            JOIN engines e ON mye.engine_id = e.id_engine
+            LEFT JOIN fuel_type ft ON e.id_fuel = ft.id_fuel
+            LEFT JOIN drivetrain dt ON mye.id_drivetrain = dt.id_drivetrain
+            LEFT JOIN transmission tr ON mye.id_transmission = tr.id_transmission
+        """
+        if with_parts:
+            base_from += " JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) AS has_parts ON mye.id_mye = has_parts.model_year_engine_id"
         where = " WHERE 1=1"
+        params = {}
+        if brand:
+            where += " AND b.name_brand ILIKE :brand"
+            params['brand'] = brand
+        if model:
+            where += " AND m.name_model ILIKE :model"
+            params['model'] = model
+        if year:
+            where += " AND y.year_car = :year"
+            params['year'] = int(year)
+        if engine_name:
+            where += " AND e.name_engine = :engine"
+            params['engine'] = engine_name
 
-    params = []
-    if brand:
-        where += " AND UPPER(b.name) = UPPER(?)"
-        params.append(brand)
-    if model:
-        where += " AND UPPER(m.name) = UPPER(?)"
-        params.append(model)
-    if year:
-        where += " AND y.year = ?"
-        params.append(int(year))
-    if engine:
-        where += " AND e.name = ?"
-        params.append(engine)
+        count_sql = text("SELECT COUNT(*) AS total " + base_from + where)
+        total_count = session.execute(count_sql, params).mappings().first()['total']
 
-    # Get total count
-    cursor.execute("SELECT COUNT(*) as total " + base_from + where, params)
-    total_count = cursor.fetchone()['total']
+        data_params = dict(params)
+        data_params['limit'] = per_page
+        data_params['offset'] = offset
+        query = text("""
+            SELECT b.name_brand AS brand, m.name_model AS model, y.year_car AS year,
+                   e.name_engine AS engine, e.power_hp, e.torque_nm, e.displacement_cc,
+                   e.cylinders, ft.name_fuel AS fuel_type, mye.trim_level,
+                   dt.name_drivetrain AS drivetrain, tr.name_transmission AS transmission
+        """ + base_from + where + " ORDER BY b.name_brand, m.name_model, y.year_car LIMIT :limit OFFSET :offset")
+        rows = session.execute(query, data_params).mappings().all()
 
-    # Get paginated data
-    query = """
-        SELECT
-            b.name AS brand,
-            m.name AS model,
-            y.year,
-            e.name AS engine,
-            e.power_hp,
-            e.torque_nm,
-            e.displacement_cc,
-            e.cylinders,
-            e.fuel_type,
-            mye.trim_level,
-            mye.drivetrain,
-            mye.transmission
-    """ + base_from + where + " ORDER BY b.name, m.name, y.year LIMIT ? OFFSET ?"
+        vehicles = []
+        for r in rows:
+            vehicles.append({
+                'brand': r['brand'], 'model': r['model'], 'year': r['year'],
+                'engine': r['engine'], 'power_hp': r['power_hp'] or 0,
+                'torque_nm': r['torque_nm'] or 0, 'displacement_cc': r['displacement_cc'] or 0,
+                'cylinders': r['cylinders'] or 0, 'fuel_type': r['fuel_type'] or 'unknown',
+                'trim_level': r['trim_level'] or 'unknown',
+                'drivetrain': r['drivetrain'] or 'unknown',
+                'transmission': r['transmission'] or 'unknown'
+            })
+        total_pages = (total_count + per_page - 1) // per_page
+        return {'data': vehicles, 'pagination': {'page': page, 'per_page': per_page,
+                'total': total_count, 'total_pages': total_pages}}
+    finally:
+        session.close()
 
-    cursor.execute(query, params + [per_page, offset])
-    results = cursor.fetchall()
-    conn.close()
 
-    vehicles = []
-    for row in results:
-        vehicle = {
-            'brand': row['brand'],
-            'model': row['model'],
-            'year': row['year'],
-            'engine': row['engine'],
-            'power_hp': row['power_hp'] or 0,
-            'torque_nm': row['torque_nm'] or 0,
-            'displacement_cc': row['displacement_cc'] or 0,
-            'cylinders': row['cylinders'] or 0,
-            'fuel_type': row['fuel_type'] or 'unknown',
-            'trim_level': row['trim_level'] or 'unknown',
-            'drivetrain': row['drivetrain'] or 'unknown',
-            'transmission': row['transmission'] or 'unknown'
-        }
-        vehicles.append(vehicle)
-
-    total_pages = (total_count + per_page - 1) // per_page
-    return {
-        'data': vehicles,
-        'pagination': {
-            'page': page,
-            'per_page': per_page,
-            'total': total_count,
-            'total_pages': total_pages
-        }
-    }
+# ============================================================================
+# Static Routes
+# ============================================================================
 
 @app.route('/')
 def index():
-    """Serve the main dashboard page"""
     return send_from_directory('.', 'index.html')
 
 @app.route('/admin')
 def admin_page():
-    """Serve the admin panel"""
     return send_from_directory('.', 'admin.html')
 
 @app.route('/landing')
 def landing_page():
-    """Serve the customer landing page"""
     return send_from_directory('.', 'customer-landing.html')
 
 @app.route('/diagramas')
 def diagrams_page():
-    """Serve the diagrams viewer page"""
     return send_from_directory('.', 'diagrams.html')
 
 @app.route('/index.html')
 def index_html():
-    """Redirect index.html to canonical route"""
     return send_from_directory('.', 'index.html')
 
 @app.route('/admin.html')
 def admin_html():
-    """Redirect admin.html to canonical route"""
     return send_from_directory('.', 'admin.html')
 
 @app.route('/customer-landing.html')
 def customer_landing_html():
-    """Serve customer-landing.html by direct path"""
     return send_from_directory('.', 'customer-landing.html')
 
 @app.route('/diagrams.html')
 def diagrams_html():
-    """Serve diagrams.html by direct path"""
     return send_from_directory('.', 'diagrams.html')
 
 @app.route('/static/<path:path>')
 def static_files(path):
-    """Serve static files from the static/ subdirectory only"""
     return send_from_directory('static', path)
 
 @app.route('/shared.css')
 def shared_css():
-    """Serve shared CSS"""
     return send_from_directory('.', 'shared.css')
 
 @app.route('/nav.js')
 def nav_js():
-    """Serve shared navigation JS"""
     return send_from_directory('.', 'nav.js')
 
 @app.route('/dashboard.js')
 def dashboard_js():
-    """Serve dashboard JS"""
     return send_from_directory('.', 'dashboard.js')
 
 @app.route('/admin.js')
 def admin_js():
-    """Serve admin JS"""
     return send_from_directory('.', 'admin.js')
 
 @app.route('/enhanced-search.js')
 def enhanced_search_js():
-    """Serve enhanced search JS"""
     return send_from_directory('.', 'enhanced-search.js')
 
+
+# ============================================================================
+# Core API Endpoints
+# ============================================================================
+
 @app.route('/api/brands')
 def api_brands():
-    """API endpoint to get all brands, optionally with model/vehicle counts"""
     detailed = request.args.get('detailed', 'false').lower() == 'true'
-    brands = get_all_brands(detailed=detailed)
-    return jsonify(brands)
+    return jsonify(get_all_brands(detailed=detailed))
+
 
 @app.route('/api/years')
 def api_years():
-    """API endpoint to get years, optionally filtered by brand and/or model"""
     brand = request.args.get('brand')
     model = request.args.get('model')
+    session = Session()
+    try:
+        q = """SELECT DISTINCT y.year_car AS year FROM years y
+               JOIN model_year_engine mye ON y.id_year = mye.year_id
+               JOIN models m ON mye.model_id = m.id_model
+               JOIN brands b ON m.brand_id = b.id_brand WHERE 1=1"""
+        params = {}
+        if brand:
+            q += " AND b.name_brand ILIKE :brand"
+            params['brand'] = brand
+        if model:
+            q += " AND m.name_model ILIKE :model"
+            params['model'] = model
+        q += " ORDER BY y.year_car DESC"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([r['year'] for r in rows])
+    finally:
+        session.close()
 
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    query = """
-        SELECT DISTINCT y.year
-        FROM years y
-        JOIN model_year_engine mye ON y.id = mye.year_id
-        JOIN models m ON mye.model_id = m.id
-        JOIN brands b ON m.brand_id = b.id
-        WHERE 1=1
-    """
-
-    params = []
-    if brand:
-        query += " AND UPPER(b.name) = UPPER(?)"
-        params.append(brand)
-    if model:
-        query += " AND UPPER(m.name) = UPPER(?)"
-        params.append(model)
-
-    query += " ORDER BY y.year DESC"
-
-    cursor.execute(query, params)
-    results = cursor.fetchall()
-    conn.close()
-
-    years = [row['year'] for row in results]
-    return jsonify(years)
 
 @app.route('/api/engines')
 def api_engines():
-    """API endpoint to get engines, optionally filtered by brand, model, and/or year"""
     brand = request.args.get('brand')
     model = request.args.get('model')
     year = request.args.get('year')
+    session = Session()
+    try:
+        q = """SELECT DISTINCT e.name_engine AS name FROM engines e
+               JOIN model_year_engine mye ON e.id_engine = mye.engine_id
+               JOIN models m ON mye.model_id = m.id_model
+               JOIN brands b ON m.brand_id = b.id_brand
+               JOIN years y ON mye.year_id = y.id_year WHERE 1=1"""
+        params = {}
+        if brand:
+            q += " AND b.name_brand ILIKE :brand"
+            params['brand'] = brand
+        if model:
+            q += " AND m.name_model ILIKE :model"
+            params['model'] = model
+        if year:
+            q += " AND y.year_car = :year"
+            params['year'] = int(year)
+        q += " ORDER BY e.name_engine"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([r['name'] for r in rows])
+    finally:
+        session.close()
 
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    query = """
-        SELECT DISTINCT e.name
-        FROM engines e
-        JOIN model_year_engine mye ON e.id = mye.engine_id
-        JOIN models m ON mye.model_id = m.id
-        JOIN brands b ON m.brand_id = b.id
-        JOIN years y ON mye.year_id = y.id
-        WHERE 1=1
-    """
-
-    params = []
-    if brand:
-        query += " AND UPPER(b.name) = UPPER(?)"
-        params.append(brand)
-    if model:
-        query += " AND UPPER(m.name) = UPPER(?)"
-        params.append(model)
-    if year:
-        query += " AND y.year = ?"
-        params.append(int(year))
-
-    query += " ORDER BY e.name"
-
-    cursor.execute(query, params)
-    results = cursor.fetchall()
-    conn.close()
-
-    engines = [row['name'] for row in results]
-    return jsonify(engines)
 
 @app.route('/api/models')
 def api_models():
-    """API endpoint to get models, optionally filtered by brand. Use detailed=true for stats."""
     brand = request.args.get('brand')
     detailed = request.args.get('detailed', 'false').lower() == 'true'
-
     if detailed and brand:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-        cursor.execute("""
-            SELECT m.name,
-                   MIN(y.year) AS year_min,
-                   MAX(y.year) AS year_max,
-                   COUNT(DISTINCT y.year) AS year_count,
-                   COUNT(DISTINCT mye.id) AS vehicle_count,
-                   COUNT(DISTINCT e.name) AS engine_count
-            FROM models m
-            JOIN brands b ON m.brand_id = b.id
-            JOIN model_year_engine mye ON mye.model_id = m.id
-            JOIN years y ON mye.year_id = y.id
-            JOIN engines e ON mye.engine_id = e.id
-            JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) vp
-              ON mye.id = vp.model_year_engine_id
-            WHERE UPPER(b.name) = UPPER(?)
-            GROUP BY m.name
-            ORDER BY m.name
-            LIMIT 1000
-        """, (brand,))
-        models = [{'name': r['name'], 'year_min': r['year_min'], 'year_max': r['year_max'],
-                    'year_count': r['year_count'], 'vehicle_count': r['vehicle_count'],
-                    'engine_count': r['engine_count']} for r in cursor.fetchall()]
-        conn.close()
-        return jsonify(models)
+        session = Session()
+        try:
+            sql = text("""
+                SELECT m.name_model AS name, MIN(y.year_car) AS year_min,
+                       MAX(y.year_car) AS year_max, COUNT(DISTINCT y.year_car) AS year_count,
+                       COUNT(DISTINCT mye.id_mye) AS vehicle_count,
+                       COUNT(DISTINCT e.name_engine) AS engine_count
+                FROM models m
+                JOIN brands b ON m.brand_id = b.id_brand
+                JOIN model_year_engine mye ON mye.model_id = m.id_model
+                JOIN years y ON mye.year_id = y.id_year
+                JOIN engines e ON mye.engine_id = e.id_engine
+                WHERE b.name_brand ILIKE :brand
+                GROUP BY m.name_model ORDER BY m.name_model LIMIT 1000
+            """)
+            rows = session.execute(sql, {'brand': brand}).mappings().all()
+            return jsonify([{'name': r['name'], 'year_min': r['year_min'], 'year_max': r['year_max'],
+                             'year_count': r['year_count'], 'vehicle_count': r['vehicle_count'],
+                             'engine_count': r['engine_count']} for r in rows])
+        finally:
+            session.close()
+    return jsonify(get_models_by_brand(brand))
 
-    models = get_models_by_brand(brand)
-    return jsonify(models)
 
 @app.route('/api/vehicles')
 def api_vehicles():
-    """API endpoint to search for vehicles with pagination"""
     brand = request.args.get('brand')
     model = request.args.get('model')
     year = request.args.get('year')
-    engine = request.args.get('engine')
+    eng = request.args.get('engine')
     page = request.args.get('page', 1, type=int)
     per_page = request.args.get('per_page', 50, type=int)
+    return jsonify(search_vehicles(brand, model, year, eng, page=page, per_page=per_page))
 
-    result = search_vehicles(brand, model, year, engine, page=page, per_page=per_page)
-    return jsonify(result)
-
-# ============================================================================
-# Parts Catalog API Endpoints
-# ============================================================================
-
-@app.route('/api/categories')
-def api_categories():
-    """API endpoint to get all part categories (hierarchical)"""
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Get all categories
-        cursor.execute("""
-            SELECT id, name, name_es, slug, icon_name, display_order, parent_id
-            FROM part_categories
-            ORDER BY display_order, name
-            LIMIT 50
-        """)
-        all_categories = cursor.fetchall()
-        conn.close()
-
-        # Build hierarchical structure
-        categories_dict = {}
-        root_categories = []
-
-        # First pass: create all category objects
-        for row in all_categories:
-            category = {
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'slug': row['slug'],
-                'icon_name': row['icon_name'],
-                'display_order': row['display_order'],
-                'children': []
-            }
-            categories_dict[row['id']] = category
-
-            if row['parent_id'] is None:
-                root_categories.append(category)
-
-        # Second pass: build hierarchy
-        for row in all_categories:
-            if row['parent_id'] is not None and row['parent_id'] in categories_dict:
-                categories_dict[row['parent_id']]['children'].append(categories_dict[row['id']])
-
-        return jsonify(root_categories)
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/categories/<int:category_id>/groups')
-def api_category_groups(category_id):
-    """API endpoint to get groups for a specific category"""
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT id, name, name_es, slug, display_order
-            FROM part_groups
-            WHERE category_id = ?
-            ORDER BY display_order, name
-            LIMIT 200
-        """, (category_id,))
-
-        groups = []
-        for row in cursor.fetchall():
-            groups.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'slug': row['slug'],
-                'display_order': row['display_order']
-            })
-
-        conn.close()
-        return jsonify(groups)
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/parts')
-def api_parts():
-    """API endpoint to list parts with optional filters and pagination"""
-    try:
-        group_id = request.args.get('group_id', type=int)
-        category_id = request.args.get('category_id', type=int)
-        search = request.args.get('search')
-        page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)  # Max 100 per page
-        offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Build base WHERE clause for both count and data queries
-        where_clause = " WHERE 1=1"
-        params = []
-
-        if group_id:
-            where_clause += " AND p.group_id = ?"
-            params.append(group_id)
-
-        if category_id:
-            where_clause += " AND pg.category_id = ?"
-            params.append(category_id)
-
-        if search:
-            where_clause += " AND (p.name LIKE ? OR p.name_es LIKE ? OR p.oem_part_number LIKE ?)"
-            search_term = f"%{search}%"
-            params.extend([search_term, search_term, search_term])
-
-        # Get total count
-        count_query = """
-            SELECT COUNT(*) as total
-            FROM parts p
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-        """ + where_clause
-        cursor.execute(count_query, params)
-        total_count = cursor.fetchone()['total']
-
-        # Get paginated data
-        data_query = """
-            SELECT
-                p.id,
-                p.oem_part_number,
-                p.name,
-                p.name_es,
-                p.group_id,
-                p.image_url,
-                pg.name AS group_name,
-                pc.name AS category_name
-            FROM parts p
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-        """ + where_clause + " ORDER BY p.name LIMIT ? OFFSET ?"
-        params.extend([per_page, offset])
-
-        cursor.execute(data_query, params)
-
-        parts = []
-        for row in cursor.fetchall():
-            parts.append({
-                'id': row['id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'group_id': row['group_id'],
-                'group_name': row['group_name'],
-                'category_name': row['category_name'],
-                'image_url': row['image_url']
-            })
-
-        conn.close()
-
-        total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': parts,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/parts/<int:part_id>')
-def api_part_detail(part_id):
-    """API endpoint to get single part details"""
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT
-                p.id,
-                p.oem_part_number,
-                p.name,
-                p.name_es,
-                p.description,
-                p.description_es,
-                p.group_id,
-                p.image_url,
-                pg.name AS group_name,
-                pg.name_es AS group_name_es,
-                pc.id AS category_id,
-                pc.name AS category_name,
-                pc.name_es AS category_name_es
-            FROM parts p
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE p.id = ?
-        """, (part_id,))
-
-        row = cursor.fetchone()
-        conn.close()
-
-        if row is None:
-            return jsonify({'error': 'Part not found'}), 404
-
-        part = {
-            'id': row['id'],
-            'oem_part_number': row['oem_part_number'],
-            'name': row['name'],
-            'name_es': row['name_es'],
-            'description': row['description'],
-            'description_es': row['description_es'],
-            'group_id': row['group_id'],
-            'group_name': row['group_name'],
-            'image_url': row['image_url'],
-            'group_name_es': row['group_name_es'],
-            'category_id': row['category_id'],
-            'category_name': row['category_name'],
-            'category_name_es': row['category_name_es']
-        }
-
-        return jsonify(part)
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/vehicles/<int:mye_id>/categories')
-def api_vehicle_categories(mye_id):
-    """API endpoint to get categories that have parts for a specific vehicle"""
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT DISTINCT
-                pc.id,
-                pc.name,
-                pc.name_es,
-                pc.slug,
-                pc.icon_name,
-                pc.display_order
-            FROM part_categories pc
-            JOIN part_groups pg ON pg.category_id = pc.id
-            JOIN parts p ON p.group_id = pg.id
-            JOIN vehicle_parts vp ON vp.part_id = p.id
-            WHERE vp.model_year_engine_id = ?
-            ORDER BY pc.display_order, pc.name
-            LIMIT 50
-        """, (mye_id,))
-
-        categories = []
-        for row in cursor.fetchall():
-            categories.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'slug': row['slug'],
-                'icon_name': row['icon_name'],
-                'display_order': row['display_order']
-            })
-
-        conn.close()
-        return jsonify(categories)
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/vehicles/<int:mye_id>/groups')
-def api_vehicle_groups(mye_id):
-    """API endpoint to get groups that have parts for a specific vehicle within a category"""
-    try:
-        category_id = request.args.get('category_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT DISTINCT
-                pg.id,
-                pg.name,
-                pg.name_es,
-                pg.slug,
-                pg.display_order,
-                COUNT(DISTINCT p.id) as parts_count
-            FROM part_groups pg
-            JOIN parts p ON p.group_id = pg.id
-            JOIN vehicle_parts vp ON vp.part_id = p.id
-            WHERE vp.model_year_engine_id = ?
-        """
-        params = [mye_id]
-
-        if category_id:
-            query += " AND pg.category_id = ?"
-            params.append(category_id)
-
-        query += " GROUP BY pg.id ORDER BY pg.display_order, pg.name LIMIT 200"
-
-        cursor.execute(query, params)
-
-        groups = []
-        for row in cursor.fetchall():
-            groups.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'slug': row['slug'],
-                'display_order': row['display_order'],
-                'parts_count': row['parts_count']
-            })
-
-        conn.close()
-        return jsonify(groups)
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/vehicles/<int:mye_id>/parts')
-def api_vehicle_parts(mye_id):
-    """API endpoint to get parts for a specific vehicle with pagination"""
-    try:
-        category_id = request.args.get('category_id', type=int)
-        group_id = request.args.get('group_id', type=int)
-        page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)
-        offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        base_query = """
-            FROM vehicle_parts vp
-            JOIN parts p ON vp.part_id = p.id
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE vp.model_year_engine_id = ?
-        """
-        params = [mye_id]
-
-        if category_id:
-            base_query += " AND pc.id = ?"
-            params.append(category_id)
-
-        if group_id:
-            base_query += " AND pg.id = ?"
-            params.append(group_id)
-
-        # Get total count
-        cursor.execute("SELECT COUNT(*) as total " + base_query, params)
-        total_count = cursor.fetchone()['total']
-
-        # Get paginated data
-        query = """
-            SELECT
-                p.id,
-                p.oem_part_number,
-                p.name,
-                p.name_es,
-                vp.quantity_required,
-                vp.position,
-                pc.name AS category_name,
-                pg.name AS group_name
-        """ + base_query + " ORDER BY pc.display_order, pg.display_order, p.name LIMIT ? OFFSET ?"
-
-        cursor.execute(query, params + [per_page, offset])
-
-        parts = []
-        for row in cursor.fetchall():
-            parts.append({
-                'id': row['id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'quantity_required': row['quantity_required'],
-                'position': row['position'],
-                'category_name': row['category_name'],
-                'group_name': row['group_name']
-            })
-
-        conn.close()
-
-        total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': parts,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
-    except Exception as e:
-        return jsonify({'error': str(e)}), 500
 
 @app.route('/api/model-year-engine')
 def api_model_year_engine():
-    """API endpoint to get model_year_engine records with filters and pagination"""
     try:
         brand = request.args.get('brand')
         model = request.args.get('model')
         year = request.args.get('year', type=int)
-        with_parts = request.args.get('with_parts', 'true').lower() == 'true'
+        with_parts = request.args.get('with_parts', 'false').lower() == 'true'
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
         offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        base_from = """
-            FROM model_year_engine mye
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-            JOIN years y ON mye.year_id = y.id
-            JOIN engines e ON mye.engine_id = e.id
-        """
-
-        # Only show vehicles that have parts — use JOIN for performance
-        if with_parts:
-            base_from += " JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) AS has_parts ON mye.id = has_parts.model_year_engine_id"
-
-        where = " WHERE 1=1"
-        params = []
-
-        if brand:
-            where += " AND UPPER(b.name) = UPPER(?)"
-            params.append(brand)
-
-        if model:
-            where += " AND UPPER(m.name) = UPPER(?)"
-            params.append(model)
-
-        if year:
-            where += " AND y.year = ?"
-            params.append(year)
-
-        # Get total count
-        cursor.execute("SELECT COUNT(*) as total " + base_from + where, params)
-        total_count = cursor.fetchone()['total']
-
-        # Get paginated data
-        query = """
-            SELECT
-                mye.id,
-                b.name AS brand,
-                m.name AS model,
-                y.year,
-                e.name AS engine,
-                mye.trim_level,
-                mye.drivetrain,
-                mye.transmission
-        """ + base_from + where + " ORDER BY b.name, m.name, y.year, e.name LIMIT ? OFFSET ?"
-
-        cursor.execute(query, params + [per_page, offset])
-
-        records = []
-        for row in cursor.fetchall():
-            records.append({
-                'id': row['id'],
-                'brand': row['brand'],
-                'model': row['model'],
-                'year': row['year'],
-                'engine': row['engine'],
-                'trim_level': row['trim_level'],
-                'drivetrain': row['drivetrain'],
-                'transmission': row['transmission']
-            })
-
-        conn.close()
-
-        total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': records,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        session = Session()
+        try:
+            base_from = """
+                FROM model_year_engine mye
+                JOIN models m ON mye.model_id = m.id_model
+                JOIN brands b ON m.brand_id = b.id_brand
+                JOIN years y ON mye.year_id = y.id_year
+                JOIN engines e ON mye.engine_id = e.id_engine
+                LEFT JOIN drivetrain dt ON mye.id_drivetrain = dt.id_drivetrain
+                LEFT JOIN transmission tr ON mye.id_transmission = tr.id_transmission
+            """
+            if with_parts:
+                base_from += " JOIN (SELECT DISTINCT model_year_engine_id FROM vehicle_parts) AS has_parts ON mye.id_mye = has_parts.model_year_engine_id"
+            where = " WHERE 1=1"
+            params = {}
+            if brand:
+                where += " AND b.name_brand ILIKE :brand"
+                params['brand'] = brand
+            if model:
+                where += " AND m.name_model ILIKE :model"
+                params['model'] = model
+            if year:
+                where += " AND y.year_car = :year"
+                params['year'] = year
+            total_count = session.execute(text("SELECT COUNT(*) AS total " + base_from + where), params).mappings().first()['total']
+            data_params = dict(params)
+            data_params['limit'] = per_page
+            data_params['offset'] = offset
+            query = text("""
+                SELECT mye.id_mye AS id, b.name_brand AS brand, m.name_model AS model,
+                       y.year_car AS year, e.name_engine AS engine, mye.trim_level,
+                       dt.name_drivetrain AS drivetrain, tr.name_transmission AS transmission
+            """ + base_from + where + " ORDER BY b.name_brand, m.name_model, y.year_car, e.name_engine LIMIT :limit OFFSET :offset")
+            rows = session.execute(query, data_params).mappings().all()
+            records = [{'id': r['id'], 'brand': r['brand'], 'model': r['model'], 'year': r['year'],
+                        'engine': r['engine'], 'trim_level': r['trim_level'],
+                        'drivetrain': r['drivetrain'], 'transmission': r['transmission']} for r in rows]
+            total_pages = (total_count + per_page - 1) // per_page
+            return jsonify({'data': records, 'pagination': {'page': page, 'per_page': per_page,
+                            'total': total_count, 'total_pages': total_pages}})
+        finally:
+            session.close()
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+
 # ============================================================================
-# FASE 2: Cross-References and Aftermarket API Endpoints
+# Parts Catalog Endpoints
+# ============================================================================
+
+@app.route('/api/categories')
+def api_categories():
+    session = Session()
+    try:
+        rows = session.execute(text("""
+            SELECT id_part_category AS id, name_part_category AS name, name_es, slug, icon_name, display_order, parent_id
+            FROM part_categories ORDER BY display_order, name_part_category LIMIT 50
+        """)).mappings().all()
+        categories_dict = {}
+        root_categories = []
+        for r in rows:
+            cat = {'id': r['id'], 'name': r['name'], 'name_es': r['name_es'], 'slug': r['slug'],
+                   'icon_name': r['icon_name'], 'display_order': r['display_order'], 'children': []}
+            categories_dict[r['id']] = cat
+            if r['parent_id'] is None:
+                root_categories.append(cat)
+        for r in rows:
+            if r['parent_id'] is not None and r['parent_id'] in categories_dict:
+                categories_dict[r['parent_id']]['children'].append(categories_dict[r['id']])
+        return jsonify(root_categories)
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
+
+
+@app.route('/api/categories/<int:category_id>/groups')
+def api_category_groups(category_id):
+    session = Session()
+    try:
+        rows = session.execute(text("""
+            SELECT id_part_group AS id, name_part_group AS name, name_es, slug, display_order
+            FROM part_groups WHERE category_id = :cid ORDER BY display_order, name_part_group LIMIT 200
+        """), {'cid': category_id}).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'slug': r['slug'], 'display_order': r['display_order']} for r in rows])
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
+
+
+@app.route('/api/parts')
+def api_parts():
+    try:
+        group_id = request.args.get('group_id', type=int)
+        category_id = request.args.get('category_id', type=int)
+        search = request.args.get('search')
+        page = request.args.get('page', 1, type=int)
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
+        offset = (page - 1) * per_page
+        session = Session()
+        try:
+            where = " WHERE 1=1"
+            params = {}
+            if group_id:
+                where += " AND p.group_id = :group_id"
+                params['group_id'] = group_id
+            if category_id:
+                where += " AND pg.category_id = :category_id"
+                params['category_id'] = category_id
+            if search:
+                where += " AND (p.name_part ILIKE :search OR p.name_es ILIKE :search OR p.oem_part_number ILIKE :search)"
+                params['search'] = '%' + search + '%'
+            base = """
+                FROM parts p
+                JOIN part_groups pg ON p.group_id = pg.id_part_group
+                JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            """
+            total_count = session.execute(text("SELECT COUNT(*) AS total " + base + where), params).mappings().first()['total']
+            data_params = dict(params)
+            data_params['limit'] = per_page
+            data_params['offset'] = offset
+            rows = session.execute(text("""
+                SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                       p.group_id, pg.name_part_group AS group_name, pc.name_part_category AS category_name
+            """ + base + where + " ORDER BY p.name_part LIMIT :limit OFFSET :offset"), data_params).mappings().all()
+            parts = [{'id': r['id'], 'oem_part_number': r['oem_part_number'], 'name': r['name'],
+                       'name_es': r['name_es'], 'group_id': r['group_id'], 'group_name': r['group_name'],
+                       'category_name': r['category_name'], 'image_url': None} for r in rows]
+            total_pages = (total_count + per_page - 1) // per_page
+            return jsonify({'data': parts, 'pagination': {'page': page, 'per_page': per_page,
+                            'total': total_count, 'total_pages': total_pages}})
+        finally:
+            session.close()
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+@app.route('/api/parts/<int:part_id>')
+def api_part_detail(part_id):
+    session = Session()
+    try:
+        row = session.execute(text("""
+            SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                   p.description, p.description_es, p.group_id,
+                   pg.name_part_group AS group_name, pg.name_es AS group_name_es,
+                   pc.id_part_category AS category_id, pc.name_part_category AS category_name,
+                   pc.name_es AS category_name_es
+            FROM parts p
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE p.id_part = :pid
+        """), {'pid': part_id}).mappings().first()
+        if row is None:
+            return jsonify({'error': 'Part not found'}), 404
+        return jsonify({'id': row['id'], 'oem_part_number': row['oem_part_number'], 'name': row['name'],
+                        'name_es': row['name_es'], 'description': row['description'],
+                        'description_es': row['description_es'], 'group_id': row['group_id'],
+                        'group_name': row['group_name'], 'image_url': None,
+                        'group_name_es': row['group_name_es'], 'category_id': row['category_id'],
+                        'category_name': row['category_name'], 'category_name_es': row['category_name_es']})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
+
+
+@app.route('/api/vehicles/<int:mye_id>/categories')
+def api_vehicle_categories(mye_id):
+    session = Session()
+    try:
+        rows = session.execute(text("""
+            SELECT DISTINCT pc.id_part_category AS id, pc.name_part_category AS name,
+                   pc.name_es, pc.slug, pc.icon_name, pc.display_order
+            FROM part_categories pc
+            JOIN part_groups pg ON pg.category_id = pc.id_part_category
+            JOIN parts p ON p.group_id = pg.id_part_group
+            JOIN vehicle_parts vp ON vp.part_id = p.id_part
+            WHERE vp.model_year_engine_id = :mye_id
+            ORDER BY pc.display_order, pc.name_part_category LIMIT 50
+        """), {'mye_id': mye_id}).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'slug': r['slug'], 'icon_name': r['icon_name'],
+                         'display_order': r['display_order']} for r in rows])
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
+
+
+@app.route('/api/vehicles/<int:mye_id>/groups')
+def api_vehicle_groups(mye_id):
+    session = Session()
+    try:
+        category_id = request.args.get('category_id', type=int)
+        q = """
+            SELECT DISTINCT pg.id_part_group AS id, pg.name_part_group AS name, pg.name_es,
+                   pg.slug, pg.display_order, COUNT(DISTINCT p.id_part) AS parts_count
+            FROM part_groups pg
+            JOIN parts p ON p.group_id = pg.id_part_group
+            JOIN vehicle_parts vp ON vp.part_id = p.id_part
+            WHERE vp.model_year_engine_id = :mye_id
+        """
+        params = {'mye_id': mye_id}
+        if category_id:
+            q += " AND pg.category_id = :cid"
+            params['cid'] = category_id
+        q += " GROUP BY pg.id_part_group, pg.name_part_group, pg.name_es, pg.slug, pg.display_order ORDER BY pg.display_order, pg.name_part_group LIMIT 200"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'slug': r['slug'], 'display_order': r['display_order'],
+                         'parts_count': r['parts_count']} for r in rows])
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
+
+
+@app.route('/api/vehicles/<int:mye_id>/parts')
+def api_vehicle_parts(mye_id):
+    try:
+        category_id = request.args.get('category_id', type=int)
+        group_id = request.args.get('group_id', type=int)
+        page = request.args.get('page', 1, type=int)
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
+        offset = (page - 1) * per_page
+        session = Session()
+        try:
+            base = """
+                FROM vehicle_parts vp
+                JOIN parts p ON vp.part_id = p.id_part
+                JOIN part_groups pg ON p.group_id = pg.id_part_group
+                JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+                WHERE vp.model_year_engine_id = :mye_id
+            """
+            params = {'mye_id': mye_id}
+            if category_id:
+                base += " AND pc.id_part_category = :cid"
+                params['cid'] = category_id
+            if group_id:
+                base += " AND pg.id_part_group = :gid"
+                params['gid'] = group_id
+            total_count = session.execute(text("SELECT COUNT(*) AS total " + base), params).mappings().first()['total']
+            data_params = dict(params)
+            data_params['limit'] = per_page
+            data_params['offset'] = offset
+            rows = session.execute(text("""
+                SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                       vp.quantity_required, pp.name_position_part AS position,
+                       pc.name_part_category AS category_name, pg.name_part_group AS group_name
+            """ + base + " ORDER BY pc.display_order, pg.display_order, p.name_part LIMIT :limit OFFSET :offset"), data_params).mappings().all()
+            parts = [{'id': r['id'], 'oem_part_number': r['oem_part_number'], 'name': r['name'],
+                       'name_es': r['name_es'], 'quantity_required': r['quantity_required'],
+                       'position': r['position'], 'category_name': r['category_name'],
+                       'group_name': r['group_name']} for r in rows]
+            total_pages = (total_count + per_page - 1) // per_page
+            return jsonify({'data': parts, 'pagination': {'page': page, 'per_page': per_page,
+                            'total': total_count, 'total_pages': total_pages}})
+        finally:
+            session.close()
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+
+# ============================================================================
+# Cross-References and Aftermarket Endpoints
 # ============================================================================
 
 @app.route('/api/manufacturers')
 def api_manufacturers():
-    """Get all manufacturers, optionally filtered by type"""
+    session = Session()
     try:
         manufacturer_type = request.args.get('type')
         quality_tier = request.args.get('quality_tier')
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT id, name, type, quality_tier, country, logo_url, website
-            FROM manufacturers
+        q = """
+            SELECT mfr.id_manufacture AS id, mfr.name_manufacture AS name,
+                   mt.name_type_manu AS type, qt.name_quality AS quality_tier,
+                   co.name_country AS country, mfr.logo_url, mfr.website
+            FROM manufacturers mfr
+            LEFT JOIN manufacture_type mt ON mfr.id_type_manu = mt.id_type_manu
+            LEFT JOIN quality_tier qt ON mfr.id_quality_tier = qt.id_quality_tier
+            LEFT JOIN countries co ON mfr.id_country = co.id_country
             WHERE 1=1
         """
-        params = []
-
+        params = {}
         if manufacturer_type:
-            query += " AND type = ?"
-            params.append(manufacturer_type)
-
+            q += " AND mt.name_type_manu ILIKE :type"
+            params['type'] = manufacturer_type
         if quality_tier:
-            query += " AND quality_tier = ?"
-            params.append(quality_tier)
-
-        query += " ORDER BY name LIMIT 200"
-
-        cursor.execute(query, params)
-
-        manufacturers = []
-        for row in cursor.fetchall():
-            manufacturers.append({
-                'id': row['id'],
-                'name': row['name'],
-                'type': row['type'],
-                'quality_tier': row['quality_tier'],
-                'country': row['country'],
-                'logo_url': row['logo_url'],
-                'website': row['website']
-            })
-
-        conn.close()
-        return jsonify(manufacturers)
+            q += " AND qt.name_quality ILIKE :qt"
+            params['qt'] = quality_tier
+        q += " ORDER BY mfr.name_manufacture LIMIT 200"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'type': r['type'],
+                         'quality_tier': r['quality_tier'], 'country': r['country'],
+                         'logo_url': r['logo_url'], 'website': r['website']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/parts/<int:part_id>/alternatives')
 def api_part_alternatives(part_id):
-    """Get aftermarket alternatives for an OEM part"""
+    session = Session()
     try:
         quality_tier = request.args.get('quality_tier')
         manufacturer_id = request.args.get('manufacturer_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT
-                ap.id,
-                ap.part_number,
-                ap.name,
-                ap.name_es,
-                m.name AS manufacturer_name,
-                ap.manufacturer_id,
-                ap.quality_tier,
-                ap.price_usd,
-                ap.warranty_months,
-                ap.in_stock
+        q = """
+            SELECT ap.id_aftermarket_parts AS id, ap.part_number, ap.name_aftermarket_parts AS name,
+                   ap.name_es, mfr.name_manufacture AS manufacturer_name, ap.manufacturer_id,
+                   qt.name_quality AS quality_tier, ap.price_usd, ap.warranty_months
             FROM aftermarket_parts ap
-            JOIN manufacturers m ON ap.manufacturer_id = m.id
-            WHERE ap.oem_part_id = ?
+            JOIN manufacturers mfr ON ap.manufacturer_id = mfr.id_manufacture
+            LEFT JOIN quality_tier qt ON ap.id_quality_tier = qt.id_quality_tier
+            WHERE ap.oem_part_id = :pid
         """
-        params = [part_id]
-
+        params = {'pid': part_id}
         if quality_tier:
-            query += " AND ap.quality_tier = ?"
-            params.append(quality_tier)
-
+            q += " AND qt.name_quality ILIKE :qt"
+            params['qt'] = quality_tier
         if manufacturer_id:
-            query += " AND ap.manufacturer_id = ?"
-            params.append(manufacturer_id)
-
-        query += " ORDER BY ap.quality_tier DESC, ap.price_usd ASC LIMIT 50"
-
-        cursor.execute(query, params)
-
-        alternatives = []
-        for row in cursor.fetchall():
-            alternatives.append({
-                'id': row['id'],
-                'part_number': row['part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'manufacturer_name': row['manufacturer_name'],
-                'manufacturer_id': row['manufacturer_id'],
-                'quality_tier': row['quality_tier'],
-                'price_usd': row['price_usd'],
-                'warranty_months': row['warranty_months'],
-                'in_stock': bool(row['in_stock']) if row['in_stock'] is not None else None
-            })
-
-        conn.close()
-        return jsonify(alternatives)
+            q += " AND ap.manufacturer_id = :mid"
+            params['mid'] = manufacturer_id
+        q += " ORDER BY qt.name_quality DESC, ap.price_usd ASC LIMIT 50"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([{'id': r['id'], 'part_number': r['part_number'], 'name': r['name'],
+                         'name_es': r['name_es'], 'manufacturer_name': r['manufacturer_name'],
+                         'manufacturer_id': r['manufacturer_id'], 'quality_tier': r['quality_tier'],
+                         'price_usd': r['price_usd'], 'warranty_months': r['warranty_months'],
+                         'in_stock': None} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/parts/<int:part_id>/cross-references')
 def api_part_cross_references(part_id):
-    """Get cross-reference numbers for a part"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT id, cross_reference_number, reference_type, source, notes
-            FROM part_cross_references
-            WHERE part_id = ?
-            ORDER BY reference_type, cross_reference_number
-            LIMIT 100
-        """, (part_id,))
-
-        cross_references = []
-        for row in cursor.fetchall():
-            cross_references.append({
-                'id': row['id'],
-                'cross_reference_number': row['cross_reference_number'],
-                'reference_type': row['reference_type'],
-                'source': row['source'],
-                'notes': row['notes']
-            })
-
-        conn.close()
-        return jsonify(cross_references)
+        rows = session.execute(text("""
+            SELECT pcr.id_part_cross_ref AS id, pcr.cross_reference_number,
+                   rt.name_ref_type AS reference_type, pcr.source_ref AS source, pcr.notes
+            FROM part_cross_references pcr
+            LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type
+            WHERE pcr.part_id = :pid
+            ORDER BY rt.name_ref_type, pcr.cross_reference_number LIMIT 100
+        """), {'pid': part_id}).mappings().all()
+        return jsonify([{'id': r['id'], 'cross_reference_number': r['cross_reference_number'],
+                         'reference_type': r['reference_type'], 'source': r['source'],
+                         'notes': r['notes']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/search/part-number/<part_number>')
 def api_search_part_number(part_number):
-    """Search for parts by any part number (OEM, aftermarket, or cross-ref)"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         results = []
-        search_term = f"%{part_number}%"
-
-        # Search in OEM parts
-        cursor.execute("""
-            SELECT id, oem_part_number, name, name_es
-            FROM parts
-            WHERE oem_part_number LIKE ?
-        """, (search_term,))
-
-        for row in cursor.fetchall():
-            results.append({
-                'id': row['id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'match_type': 'oem',
-                'matched_number': row['oem_part_number']
-            })
-
-        # Search in aftermarket parts
-        cursor.execute("""
-            SELECT p.id, p.oem_part_number, p.name, p.name_es, ap.part_number
-            FROM aftermarket_parts ap
-            JOIN parts p ON ap.oem_part_id = p.id
-            WHERE ap.part_number LIKE ?
-        """, (search_term,))
-
-        for row in cursor.fetchall():
-            results.append({
-                'id': row['id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'match_type': 'aftermarket',
-                'matched_number': row['part_number']
-            })
-
-        # Search in cross-references
-        cursor.execute("""
-            SELECT p.id, p.oem_part_number, p.name, p.name_es, pcr.cross_reference_number
-            FROM part_cross_references pcr
-            JOIN parts p ON pcr.part_id = p.id
-            WHERE pcr.cross_reference_number LIKE ?
-        """, (search_term,))
-
-        for row in cursor.fetchall():
-            results.append({
-                'id': row['id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'match_type': 'cross_reference',
-                'matched_number': row['cross_reference_number']
-            })
-
-        conn.close()
+        st = '%' + part_number + '%'
+        for row in session.execute(text("SELECT id_part AS id, oem_part_number, name_part AS name, name_es FROM parts WHERE oem_part_number ILIKE :s"), {'s': st}).mappings().all():
+            results.append({'id': row['id'], 'oem_part_number': row['oem_part_number'], 'name': row['name'], 'name_es': row['name_es'], 'match_type': 'oem', 'matched_number': row['oem_part_number']})
+        for row in session.execute(text("SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es, ap.part_number FROM aftermarket_parts ap JOIN parts p ON ap.oem_part_id = p.id_part WHERE ap.part_number ILIKE :s"), {'s': st}).mappings().all():
+            results.append({'id': row['id'], 'oem_part_number': row['oem_part_number'], 'name': row['name'], 'name_es': row['name_es'], 'match_type': 'aftermarket', 'matched_number': row['part_number']})
+        for row in session.execute(text("SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es, pcr.cross_reference_number FROM part_cross_references pcr JOIN parts p ON pcr.part_id = p.id_part WHERE pcr.cross_reference_number ILIKE :s"), {'s': st}).mappings().all():
+            results.append({'id': row['id'], 'oem_part_number': row['oem_part_number'], 'name': row['name'], 'name_es': row['name_es'], 'match_type': 'cross_reference', 'matched_number': row['cross_reference_number']})
         return jsonify(results)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/aftermarket')
 def api_aftermarket_parts():
-    """List aftermarket parts with filters and pagination"""
+    session = Session()
     try:
         manufacturer_id = request.args.get('manufacturer_id', type=int)
         quality_tier = request.args.get('quality_tier')
         search = request.args.get('search')
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)  # Max 100 per page
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
         offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Build base WHERE clause for both count and data queries
-        where_clause = " WHERE 1=1"
-        params = []
-
+        where = " WHERE 1=1"
+        params = {}
         if manufacturer_id:
-            where_clause += " AND ap.manufacturer_id = ?"
-            params.append(manufacturer_id)
-
+            where += " AND ap.manufacturer_id = :mid"
+            params['mid'] = manufacturer_id
         if quality_tier:
-            where_clause += " AND ap.quality_tier = ?"
-            params.append(quality_tier)
-
+            where += " AND qt.name_quality ILIKE :qt"
+            params['qt'] = quality_tier
         if search:
-            where_clause += " AND (ap.name LIKE ? OR ap.part_number LIKE ? OR p.oem_part_number LIKE ?)"
-            search_term = f"%{search}%"
-            params.extend([search_term, search_term, search_term])
-
-        # Get total count
-        count_query = """
-            SELECT COUNT(*) as total
+            where += " AND (ap.name_aftermarket_parts ILIKE :s OR ap.part_number ILIKE :s OR p.oem_part_number ILIKE :s)"
+            params['s'] = '%' + search + '%'
+        base = """
             FROM aftermarket_parts ap
-            JOIN parts p ON ap.oem_part_id = p.id
-            JOIN manufacturers m ON ap.manufacturer_id = m.id
-        """ + where_clause
-        cursor.execute(count_query, params)
-        total_count = cursor.fetchone()['total']
-
-        # Get paginated data
-        data_query = """
-            SELECT
-                ap.id,
-                ap.part_number,
-                ap.name,
-                p.oem_part_number,
-                m.name AS manufacturer_name,
-                ap.quality_tier,
-                ap.price_usd
-            FROM aftermarket_parts ap
-            JOIN parts p ON ap.oem_part_id = p.id
-            JOIN manufacturers m ON ap.manufacturer_id = m.id
-        """ + where_clause + " ORDER BY ap.name LIMIT ? OFFSET ?"
-        params.extend([per_page, offset])
-
-        cursor.execute(data_query, params)
-
-        parts = []
-        for row in cursor.fetchall():
-            parts.append({
-                'id': row['id'],
-                'part_number': row['part_number'],
-                'name': row['name'],
-                'oem_part_number': row['oem_part_number'],
-                'manufacturer_name': row['manufacturer_name'],
-                'quality_tier': row['quality_tier'],
-                'price_usd': row['price_usd']
-            })
-
-        conn.close()
-
+            JOIN parts p ON ap.oem_part_id = p.id_part
+            JOIN manufacturers m ON ap.manufacturer_id = m.id_manufacture
+            LEFT JOIN quality_tier qt ON ap.id_quality_tier = qt.id_quality_tier
+        """
+        total_count = session.execute(text("SELECT COUNT(*) AS total " + base + where), params).mappings().first()['total']
+        data_params = dict(params)
+        data_params['limit'] = per_page
+        data_params['offset'] = offset
+        rows = session.execute(text("""
+            SELECT ap.id_aftermarket_parts AS id, ap.part_number, ap.name_aftermarket_parts AS name,
+                   p.oem_part_number, m.name_manufacture AS manufacturer_name,
+                   qt.name_quality AS quality_tier, ap.price_usd
+        """ + base + where + " ORDER BY ap.name_aftermarket_parts LIMIT :limit OFFSET :offset"), data_params).mappings().all()
+        parts = [{'id': r['id'], 'part_number': r['part_number'], 'name': r['name'],
+                   'oem_part_number': r['oem_part_number'], 'manufacturer_name': r['manufacturer_name'],
+                   'quality_tier': r['quality_tier'], 'price_usd': r['price_usd']} for r in rows]
         total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': parts,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        return jsonify({'data': parts, 'pagination': {'page': page, 'per_page': per_page,
+                        'total': total_count, 'total_pages': total_pages}})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ============================================================================
-# FASE 3: Exploded Diagrams API Endpoints
+# Diagram Endpoints
 # ============================================================================
 
 @app.route('/api/diagrams')
 def api_diagrams():
-    """Get all diagrams, optionally filtered by group_id"""
+    session = Session()
     try:
         group_id = request.args.get('group_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT
-                d.id,
-                d.name,
-                d.name_es,
-                d.group_id,
-                pg.name AS group_name,
-                d.thumbnail_path,
-                d.display_order
-            FROM diagrams d
-            JOIN part_groups pg ON d.group_id = pg.id
-            WHERE 1=1
+        q = """
+            SELECT d.id_diagram AS id, d.name_diagram AS name, d.name_es, d.group_id,
+                   pg.name_part_group AS group_name, d.thumbnail_path, d.display_order
+            FROM diagrams d JOIN part_groups pg ON d.group_id = pg.id_part_group WHERE 1=1
         """
-        params = []
-
+        params = {}
         if group_id:
-            query += " AND d.group_id = ?"
-            params.append(group_id)
-
-        query += " ORDER BY d.display_order, d.name LIMIT 200"
-
-        cursor.execute(query, params)
-
-        diagrams = []
-        for row in cursor.fetchall():
-            diagrams.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'group_id': row['group_id'],
-                'group_name': row['group_name'],
-                'thumbnail_path': row['thumbnail_path'],
-                'display_order': row['display_order']
-            })
-
-        conn.close()
-        return jsonify(diagrams)
+            q += " AND d.group_id = :gid"
+            params['gid'] = group_id
+        q += " ORDER BY d.display_order, d.name_diagram LIMIT 200"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'group_id': r['group_id'], 'group_name': r['group_name'],
+                         'thumbnail_path': r['thumbnail_path'], 'display_order': r['display_order']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/diagrams/<int:diagram_id>')
 def api_diagram_detail(diagram_id):
-    """Get diagram details including SVG content and hotspots"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Get diagram details
-        cursor.execute("""
-            SELECT
-                d.id,
-                d.name,
-                d.name_es,
-                d.group_id,
-                pg.name AS group_name,
-                d.image_path,
-                d.svg_content,
-                d.width,
-                d.height
-            FROM diagrams d
-            JOIN part_groups pg ON d.group_id = pg.id
-            WHERE d.id = ?
-        """, (diagram_id,))
-
-        row = cursor.fetchone()
-
+        row = session.execute(text("""
+            SELECT d.id_diagram AS id, d.name_diagram AS name, d.name_es, d.group_id,
+                   pg.name_part_group AS group_name, d.image_path
+            FROM diagrams d JOIN part_groups pg ON d.group_id = pg.id_part_group
+            WHERE d.id_diagram = :did
+        """), {'did': diagram_id}).mappings().first()
         if row is None:
-            conn.close()
             return jsonify({'error': 'Diagram not found'}), 404
-
         image_path = row['image_path'] or ''
         image_url = '/' + image_path if image_path and not image_path.startswith('/') else image_path
-
-        diagram = {
-            'id': row['id'],
-            'name': row['name'],
-            'name_es': row['name_es'],
-            'group_id': row['group_id'],
-            'group_name': row['group_name'],
-            'image_path': image_path,
-            'image_url': image_url,
-            'svg_content': row['svg_content'],
-            'width': row['width'],
-            'height': row['height'],
-            'hotspots': []
-        }
-
-        # Get hotspots with part info
-        cursor.execute("""
-            SELECT
-                h.id,
-                h.part_id,
-                h.callout_number,
-                h.label,
-                h.shape,
-                h.coords,
-                h.color,
-                p.name AS part_name,
-                p.oem_part_number AS part_number
+        diagram = {'id': row['id'], 'name': row['name'], 'name_es': row['name_es'],
+                   'group_id': row['group_id'], 'group_name': row['group_name'],
+                   'image_path': image_path, 'image_url': image_url,
+                   'svg_content': None, 'width': None, 'height': None, 'hotspots': []}
+        hotspot_rows = session.execute(text("""
+            SELECT h.id_dgr_hotspot AS id, h.part_id, h.callout_number,
+                   sh.name_shape AS shape, h.coords,
+                   p.name_part AS part_name, p.oem_part_number AS part_number
             FROM diagram_hotspots h
-            LEFT JOIN parts p ON h.part_id = p.id
-            WHERE h.diagram_id = ?
-            ORDER BY h.callout_number
-        """, (diagram_id,))
-
-        for hotspot_row in cursor.fetchall():
-            diagram['hotspots'].append({
-                'id': hotspot_row['id'],
-                'part_id': hotspot_row['part_id'],
-                'callout_number': hotspot_row['callout_number'],
-                'label': hotspot_row['label'],
-                'shape': hotspot_row['shape'],
-                'coords': hotspot_row['coords'],
-                'color': hotspot_row['color'],
-                'part_name': hotspot_row['part_name'],
-                'part_number': hotspot_row['part_number']
-            })
-
-        conn.close()
+            LEFT JOIN parts p ON h.part_id = p.id_part
+            LEFT JOIN shapes sh ON h.id_shape = sh.id_shape
+            WHERE h.diagram_id = :did ORDER BY h.callout_number
+        """), {'did': diagram_id}).mappings().all()
+        for hr in hotspot_rows:
+            diagram['hotspots'].append({'id': hr['id'], 'part_id': hr['part_id'],
+                'callout_number': hr['callout_number'], 'label': None, 'shape': hr['shape'],
+                'coords': hr['coords'], 'color': None, 'part_name': hr['part_name'],
+                'part_number': hr['part_number']})
         return jsonify(diagram)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/diagrams/<int:diagram_id>/hotspots')
 def api_diagram_hotspots(diagram_id):
-    """Get all hotspots for a specific diagram"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT
-                h.id,
-                h.part_id,
-                h.callout_number,
-                h.label,
-                h.shape,
-                h.coords,
-                h.color,
-                p.name AS part_name,
-                p.oem_part_number AS part_number
+        rows = session.execute(text("""
+            SELECT h.id_dgr_hotspot AS id, h.part_id, h.callout_number,
+                   sh.name_shape AS shape, h.coords,
+                   p.name_part AS part_name, p.oem_part_number AS part_number
             FROM diagram_hotspots h
-            LEFT JOIN parts p ON h.part_id = p.id
-            WHERE h.diagram_id = ?
-            ORDER BY h.callout_number
-            LIMIT 500
-        """, (diagram_id,))
-
-        hotspots = []
-        for row in cursor.fetchall():
-            hotspots.append({
-                'id': row['id'],
-                'part_id': row['part_id'],
-                'callout_number': row['callout_number'],
-                'label': row['label'],
-                'shape': row['shape'],
-                'coords': row['coords'],
-                'color': row['color'],
-                'part_name': row['part_name'],
-                'part_number': row['part_number']
-            })
-
-        conn.close()
-        return jsonify(hotspots)
+            LEFT JOIN parts p ON h.part_id = p.id_part
+            LEFT JOIN shapes sh ON h.id_shape = sh.id_shape
+            WHERE h.diagram_id = :did ORDER BY h.callout_number LIMIT 500
+        """), {'did': diagram_id}).mappings().all()
+        return jsonify([{'id': r['id'], 'part_id': r['part_id'], 'callout_number': r['callout_number'],
+                         'label': None, 'shape': r['shape'], 'coords': r['coords'], 'color': None,
+                         'part_name': r['part_name'], 'part_number': r['part_number']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/groups/<int:group_id>/diagrams')
 def api_group_diagrams(group_id):
-    """Get all diagrams for a specific part group"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT
-                id,
-                name,
-                name_es,
-                thumbnail_path,
-                display_order
-            FROM diagrams
-            WHERE group_id = ?
-            ORDER BY display_order, name
-            LIMIT 100
-        """, (group_id,))
-
-        diagrams = []
-        for row in cursor.fetchall():
-            diagrams.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'thumbnail_path': row['thumbnail_path'],
-                'display_order': row['display_order']
-            })
-
-        conn.close()
-        return jsonify(diagrams)
+        rows = session.execute(text("""
+            SELECT id_diagram AS id, name_diagram AS name, name_es, thumbnail_path, display_order
+            FROM diagrams WHERE group_id = :gid ORDER BY display_order, name_diagram LIMIT 100
+        """), {'gid': group_id}).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'thumbnail_path': r['thumbnail_path'], 'display_order': r['display_order']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/vehicles/<int:mye_id>/diagrams')
 def api_vehicle_diagrams(mye_id):
-    """Get diagrams available for a specific vehicle configuration"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT DISTINCT
-                d.id,
-                d.name,
-                d.name_es,
-                d.group_id,
-                d.image_path,
-                pg.name AS group_name,
-                pc.id AS category_id,
-                pc.name AS category_name,
-                d.thumbnail_path,
-                vd.notes
+        rows = session.execute(text("""
+            SELECT DISTINCT d.id_diagram AS id, d.name_diagram AS name, d.name_es,
+                   d.group_id, d.image_path, pg.name_part_group AS group_name,
+                   pc.id_part_category AS category_id, pc.name_part_category AS category_name,
+                   d.thumbnail_path, vd.notes
             FROM vehicle_diagrams vd
-            JOIN diagrams d ON vd.diagram_id = d.id
-            JOIN part_groups pg ON d.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE vd.model_year_engine_id = ?
-            ORDER BY pc.display_order, pg.display_order, d.display_order
-            LIMIT 200
-        """, (mye_id,))
-
+            JOIN diagrams d ON vd.diagram_id = d.id_diagram
+            JOIN part_groups pg ON d.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE vd.model_year_engine_id = :mye_id
+            ORDER BY pc.display_order, pg.display_order, d.display_order LIMIT 200
+        """), {'mye_id': mye_id}).mappings().all()
         diagrams = []
-        for row in cursor.fetchall():
-            image_path = row['image_path'] or ''
-            image_url = '/' + image_path if image_path and not image_path.startswith('/') else image_path
-            diagrams.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'group_id': row['group_id'],
-                'group_name': row['group_name'],
-                'category_id': row['category_id'],
-                'category_name': row['category_name'],
-                'image_url': image_url,
-                'thumbnail_path': row['thumbnail_path'],
-                'notes': row['notes']
-            })
-
-        conn.close()
+        for r in rows:
+            ip = r['image_path'] or ''
+            iu = '/' + ip if ip and not ip.startswith('/') else ip
+            diagrams.append({'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                             'group_id': r['group_id'], 'group_name': r['group_name'],
+                             'category_id': r['category_id'], 'category_name': r['category_name'],
+                             'image_url': iu, 'thumbnail_path': r['thumbnail_path'], 'notes': r['notes']})
         return jsonify(diagrams)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/diagrams/<int:diagram_id>/parts')
 def api_diagram_parts(diagram_id):
-    """Get all parts associated with a diagram via vehicle fitment.
-    Optional query param: mye_id - filter to a specific vehicle configuration."""
+    session = Session()
     try:
         mye_id = request.args.get('mye_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Get parts linked to vehicles that use this diagram
-        # Filter to suspension (cat 10, 11) related parts only
-        query = """
-            SELECT DISTINCT
-                p.id,
-                p.oem_part_number,
-                p.name,
-                p.name_es,
-                p.description,
-                pg.id AS group_id,
-                pg.name AS group_name,
-                pg.name_es AS group_name_es
+        q = """
+            SELECT DISTINCT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                   p.description, pg.id_part_group AS group_id, pg.name_part_group AS group_name,
+                   pg.name_es AS group_name_es
             FROM vehicle_diagrams vd
             JOIN vehicle_parts vp ON vp.model_year_engine_id = vd.model_year_engine_id
-            JOIN parts p ON vp.part_id = p.id
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE vd.diagram_id = ?
-              AND pc.id IN (10, 11)
+            JOIN parts p ON vp.part_id = p.id_part
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE vd.diagram_id = :did AND pc.id_part_category IN (10, 11)
         """
-        params = [diagram_id]
-
+        params = {'did': diagram_id}
         if mye_id:
-            query += " AND vd.model_year_engine_id = ?"
-            params.append(mye_id)
-
-        query += " ORDER BY pg.name, p.oem_part_number LIMIT 200"
-
-        cursor.execute(query, params)
-        rows = cursor.fetchall()
-
-        # Batch-fetch cross-references for all parts (fixes N+1 query)
+            q += " AND vd.model_year_engine_id = :mye_id"
+            params['mye_id'] = mye_id
+        q += " ORDER BY pg.name_part_group, p.oem_part_number LIMIT 200"
+        rows = session.execute(text(q), params).mappings().all()
+        # Batch cross-refs (N+1 fix)
         xrefs_map = {}
         if rows:
-            part_ids = list(set(row['id'] for row in rows))
-            placeholders = ','.join('?' * len(part_ids))
-            cursor.execute(f"""
-                SELECT part_id, cross_reference_number, source
-                FROM part_cross_references
-                WHERE part_id IN ({placeholders})
-            """, part_ids)
-            for xrow in cursor.fetchall():
-                xrefs_map.setdefault(xrow['part_id'], []).append(
-                    {'number': xrow['cross_reference_number'], 'source': xrow['source']}
-                )
-
-        parts = []
-        for row in rows:
-            parts.append({
-                'id': row['id'],
-                'part_number': row['oem_part_number'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'description': row['description'],
-                'group_name': row['group_name'],
-                'group_name_es': row['group_name_es'],
-                'cross_references': xrefs_map.get(row['id'], []),
-            })
-
-        conn.close()
-        return jsonify(parts)
+            part_ids = list(set(r['id'] for r in rows))
+            in_params = {}
+            in_pl = []
+            for i, pid in enumerate(part_ids):
+                in_params[f'pid_{i}'] = pid
+                in_pl.append(f':pid_{i}')
+            xref_rows = session.execute(text(f"""
+                SELECT part_id, cross_reference_number, source_ref AS source
+                FROM part_cross_references WHERE part_id IN ({', '.join(in_pl)})
+            """), in_params).mappings().all()
+            for xr in xref_rows:
+                xrefs_map.setdefault(xr['part_id'], []).append({'number': xr['cross_reference_number'], 'source': xr['source']})
+        return jsonify([{'id': r['id'], 'part_number': r['oem_part_number'], 'name': r['name'],
+                         'name_es': r['name_es'], 'description': r['description'],
+                         'group_name': r['group_name'], 'group_name_es': r['group_name_es'],
+                         'cross_references': xrefs_map.get(r['id'], [])} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/diagrams/search')
 def api_diagrams_search():
-    """Search diagrams by figure code or vehicle brand/model."""
+    session = Session()
     try:
         q = request.args.get('q', '').strip()
         brand = request.args.get('brand', '').strip()
         model = request.args.get('model', '').strip()
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         if q:
-            cursor.execute("""
-                SELECT DISTINCT d.id, d.name, d.name_es, d.image_path, d.source
-                FROM diagrams d
-                WHERE d.name LIKE ? OR d.name_es LIKE ?
-                ORDER BY d.name
-                LIMIT 50
-            """, (f'%{q}%', f'%{q}%'))
+            rows = session.execute(text("""
+                SELECT DISTINCT d.id_diagram AS id, d.name_diagram AS name, d.name_es,
+                       d.image_path, d.source_diagram AS source
+                FROM diagrams d WHERE d.name_diagram ILIKE :q OR d.name_es ILIKE :q
+                ORDER BY d.name_diagram LIMIT 50
+            """), {'q': '%' + q + '%'}).mappings().all()
         elif brand or model:
-            params = []
-            query = """
-                SELECT DISTINCT d.id, d.name, d.name_es, d.image_path, d.source
+            sql = """
+                SELECT DISTINCT d.id_diagram AS id, d.name_diagram AS name, d.name_es,
+                       d.image_path, d.source_diagram AS source
                 FROM diagrams d
-                JOIN vehicle_diagrams vd ON vd.diagram_id = d.id
-                JOIN model_year_engine mye ON vd.model_year_engine_id = mye.id
-                JOIN models m ON mye.model_id = m.id
-                JOIN brands b ON m.brand_id = b.id
-                WHERE 1=1
+                JOIN vehicle_diagrams vd ON vd.diagram_id = d.id_diagram
+                JOIN model_year_engine mye ON vd.model_year_engine_id = mye.id_mye
+                JOIN models m ON mye.model_id = m.id_model
+                JOIN brands b ON m.brand_id = b.id_brand WHERE 1=1
             """
+            params = {}
             if brand:
-                query += " AND UPPER(b.name) = UPPER(?)"
-                params.append(brand)
+                sql += " AND b.name_brand ILIKE :brand"
+                params['brand'] = brand
             if model:
-                query += " AND UPPER(m.name) = UPPER(?)"
-                params.append(model)
-            query += " ORDER BY d.name LIMIT 50"
-            cursor.execute(query, params)
+                sql += " AND m.name_model ILIKE :model"
+                params['model'] = model
+            sql += " ORDER BY d.name_diagram LIMIT 50"
+            rows = session.execute(text(sql), params).mappings().all()
         else:
-            cursor.execute("""
-                SELECT d.id, d.name, d.name_es, d.image_path, d.source
-                FROM diagrams d
-                WHERE d.source = 'MOOG Catalog'
-                ORDER BY d.name
-                LIMIT 50
-            """)
-
-        diagrams = []
-        for row in cursor.fetchall():
-            diagrams.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'image_path': row['image_path'],
-                'source': row['source'],
-            })
-
-        conn.close()
-        return jsonify(diagrams)
+            rows = session.execute(text("""
+                SELECT d.id_diagram AS id, d.name_diagram AS name, d.name_es,
+                       d.image_path, d.source_diagram AS source
+                FROM diagrams d WHERE d.source_diagram = 'MOOG Catalog'
+                ORDER BY d.name_diagram LIMIT 50
+            """)).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'image_path': r['image_path'], 'source': r['source']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/hotspots/<int:hotspot_id>')
 def api_hotspot_detail(hotspot_id):
-    """Get hotspot details including linked part info"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            SELECT
-                h.id,
-                h.diagram_id,
-                h.part_id,
-                h.callout_number,
-                h.label,
-                h.shape,
-                h.coords,
-                h.color
+        row = session.execute(text("""
+            SELECT h.id_dgr_hotspot AS id, h.diagram_id, h.part_id, h.callout_number,
+                   sh.name_shape AS shape, h.coords
             FROM diagram_hotspots h
-            WHERE h.id = ?
-        """, (hotspot_id,))
-
-        row = cursor.fetchone()
-
+            LEFT JOIN shapes sh ON h.id_shape = sh.id_shape
+            WHERE h.id_dgr_hotspot = :hid
+        """), {'hid': hotspot_id}).mappings().first()
         if row is None:
-            conn.close()
             return jsonify({'error': 'Hotspot not found'}), 404
-
-        hotspot = {
-            'id': row['id'],
-            'diagram_id': row['diagram_id'],
-            'part_id': row['part_id'],
-            'callout_number': row['callout_number'],
-            'label': row['label'],
-            'shape': row['shape'],
-            'coords': row['coords'],
-            'color': row['color'],
-            'part': None
-        }
-
-        # Get linked part info if part_id exists
+        hotspot = {'id': row['id'], 'diagram_id': row['diagram_id'], 'part_id': row['part_id'],
+                   'callout_number': row['callout_number'], 'label': None, 'shape': row['shape'],
+                   'coords': row['coords'], 'color': None, 'part': None}
         if row['part_id']:
-            cursor.execute("""
-                SELECT
-                    p.id,
-                    p.oem_part_number,
-                    p.name,
-                    p.name_es,
-                    pg.name AS group_name,
-                    pc.name AS category_name
-                FROM parts p
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE p.id = ?
-            """, (row['part_id'],))
-
-            part_row = cursor.fetchone()
-            if part_row:
-                hotspot['part'] = {
-                    'id': part_row['id'],
-                    'oem_part_number': part_row['oem_part_number'],
-                    'name': part_row['name'],
-                    'name_es': part_row['name_es'],
-                    'group_name': part_row['group_name'],
-                    'category_name': part_row['category_name']
-                }
-
-        conn.close()
+            pr = session.execute(text("""
+                SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                       pg.name_part_group AS group_name, pc.name_part_category AS category_name
+                FROM parts p JOIN part_groups pg ON p.group_id = pg.id_part_group
+                JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                WHERE p.id_part = :pid
+            """), {'pid': row['part_id']}).mappings().first()
+            if pr:
+                hotspot['part'] = {'id': pr['id'], 'oem_part_number': pr['oem_part_number'],
+                                   'name': pr['name'], 'name_es': pr['name_es'],
+                                   'group_name': pr['group_name'], 'category_name': pr['category_name']}
         return jsonify(hotspot)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ============================================================================
-# FASE 4: Full-Text Search and VIN Decoder API Endpoints
+# Search and VIN Endpoints
 # ============================================================================
 
-import urllib.request
-import json as json_module
-import re
-from datetime import datetime, timedelta
-
 def validate_vin(vin):
-    """Validate VIN format: 17 alphanumeric characters, no I, O, Q"""
     if not vin or len(vin) != 17:
         return False
-    # VIN can only contain alphanumeric characters except I, O, Q
-    valid_pattern = re.compile(r'^[A-HJ-NPR-Z0-9]{17}$', re.IGNORECASE)
-    return bool(valid_pattern.match(vin))
+    return bool(re.compile(r'^[A-HJ-NPR-Z0-9]{17}$', re.IGNORECASE).match(vin))
 
 
-def find_vehicle_in_terms(cursor, terms):
-    """
-    Try to find a vehicle match in the search terms.
-    Returns (matched_vehicle, remaining_terms) or (None, terms) if no match.
-
-    Strategy: Try different combinations of terms to find a vehicle match.
-    - First try all terms that could be vehicle-related (brand, model, year)
-    - Return the best match and remaining terms for part search
-    """
+def find_vehicle_in_terms(session, terms):
     if len(terms) < 2:
         return None, terms
-
-    # Identify potential year terms (4-digit numbers between 1980-2030)
     year_terms = []
     other_terms = []
-    for term in terms:
-        if term.isdigit() and 1980 <= int(term) <= 2030:
-            year_terms.append(term)
+    for t in terms:
+        if t.isdigit() and 1980 <= int(t) <= 2030:
+            year_terms.append(t)
         else:
-            other_terms.append(term)
-
-    # Try to find a vehicle with the non-year terms + year
-    # We need at least one non-year term and preferably a year
+            other_terms.append(t)
     if not other_terms:
         return None, terms
-
-    # Build query to find matching vehicle
-    # Try with different combinations
     best_match = None
     used_terms = []
-
     for num_terms in range(min(3, len(other_terms)), 0, -1):
         if best_match:
             break
-
-        # Try combinations of other_terms
         for i in range(len(other_terms) - num_terms + 1):
             test_terms = other_terms[i:i + num_terms]
             if year_terms:
-                test_terms = test_terms + year_terms[:1]  # Add first year
-
+                test_terms = test_terms + year_terms[:1]
             where_clauses = []
-            params = []
-
-            for term in test_terms:
-                term_pattern = f"%{term}%"
-                where_clauses.append(
-                    "(b.name LIKE ? OR m.name LIKE ? OR CAST(y.year AS TEXT) LIKE ?)"
-                )
-                params.extend([term_pattern, term_pattern, term_pattern])
-
+            params = {}
+            for idx, t in enumerate(test_terms):
+                tp = f"%{t}%"
+                where_clauses.append(f"(b.name_brand ILIKE :t{idx}_b OR m.name_model ILIKE :t{idx}_m OR CAST(y.year_car AS TEXT) ILIKE :t{idx}_y)")
+                params[f't{idx}_b'] = tp
+                params[f't{idx}_m'] = tp
+                params[f't{idx}_y'] = tp
             where_sql = " AND ".join(where_clauses)
-
-            cursor.execute(f"""
-                SELECT
-                    mye.id,
-                    b.name AS brand,
-                    m.name AS model,
-                    y.year,
-                    e.name AS engine
+            row = session.execute(text(f"""
+                SELECT mye.id_mye AS id, b.name_brand AS brand, m.name_model AS model,
+                       y.year_car AS year, e.name_engine AS engine
                 FROM model_year_engine mye
-                JOIN models m ON mye.model_id = m.id
-                JOIN brands b ON m.brand_id = b.id
-                JOIN years y ON mye.year_id = y.id
-                JOIN engines e ON mye.engine_id = e.id
-                WHERE {where_sql}
-                ORDER BY y.year DESC
-                LIMIT 1
-            """, params)
-
-            row = cursor.fetchone()
+                JOIN models m ON mye.model_id = m.id_model
+                JOIN brands b ON m.brand_id = b.id_brand
+                JOIN years y ON mye.year_id = y.id_year
+                JOIN engines e ON mye.engine_id = e.id_engine
+                WHERE {where_sql} ORDER BY y.year_car DESC LIMIT 1
+            """), params).mappings().first()
             if row:
-                best_match = {
-                    'id': row['id'],
-                    'brand': row['brand'],
-                    'model': row['model'],
-                    'year': row['year'],
-                    'engine': row['engine']
-                }
+                best_match = {'id': row['id'], 'brand': row['brand'], 'model': row['model'],
+                              'year': row['year'], 'engine': row['engine']}
                 used_terms = test_terms
                 break
-
     if best_match:
-        # Calculate remaining terms (terms not used for vehicle match)
         remaining = []
         used_lower = [t.lower() for t in used_terms]
-        for term in terms:
-            if term.lower() not in used_lower:
-                remaining.append(term)
+        for t in terms:
+            if t.lower() not in used_lower:
+                remaining.append(t)
             else:
-                # Remove from used_lower to handle duplicates
-                used_lower.remove(term.lower())
-
+                used_lower.remove(t.lower())
         return best_match, remaining
-
     return None, terms
 
 
 @app.route('/api/search')
 def api_search():
-    """Unified search across parts, cross-references, and aftermarket"""
+    session = Session()
     try:
         q = request.args.get('q', '').strip()
         search_type = request.args.get('type', 'all')
         category_id = request.args.get('category_id', type=int)
         limit = request.args.get('limit', 50, type=int)
         offset = request.args.get('offset', 0, type=int)
-
         if not q:
             return jsonify({'error': 'Search query is required'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        results = {
-            'parts': [],
-            'vehicles': [],
-            'vehicle_parts': [],  # Parts for a specific vehicle
-            'matched_vehicle': None,  # Vehicle matched in combined search
-            'total_count': 0
-        }
-
+        results = {'parts': [], 'vehicles': [], 'vehicle_parts': [], 'matched_vehicle': None, 'total_count': 0}
         terms = q.split()
 
-        # Try to detect combined vehicle + part search
-        # Look for patterns like "aveo 2024 balata" or "camry brake pad"
+        # Combined vehicle + part search
         if len(terms) >= 2 and search_type == 'all':
-            matched_vehicle, remaining_terms = find_vehicle_in_terms(cursor, terms)
-
+            matched_vehicle, remaining_terms = find_vehicle_in_terms(session, terms)
             if matched_vehicle and remaining_terms:
                 results['matched_vehicle'] = matched_vehicle
-
-                # Search for parts compatible with this vehicle (all engine variants)
-                part_terms = remaining_terms
-                if part_terms:
-                    vp_where_clauses = []
-                    # Search across ALL MYE IDs for same brand/model/year (all engine variants)
-                    vp_params = [matched_vehicle['brand'], matched_vehicle['model'], matched_vehicle['year']]
-
-                    for term in part_terms:
-                        term_pattern = f"%{term}%"
-                        vp_where_clauses.append(
-                            "(p.name LIKE ? OR p.name_es LIKE ? OR p.oem_part_number LIKE ? OR pg.name LIKE ?)"
-                        )
-                        vp_params.extend([term_pattern, term_pattern, term_pattern, term_pattern])
-
-                    vp_where_sql = " AND ".join(vp_where_clauses)
-                    vp_params.extend([limit])
-
-                    cursor.execute(f"""
-                        SELECT DISTINCT
-                            p.id,
-                            p.oem_part_number,
-                            p.name,
-                            p.name_es,
-                            p.image_url,
-                            pg.name AS group_name,
-                            pg.id AS group_id,
-                            pc.name AS category_name,
-                            pc.id AS category_id,
-                            vp.quantity_required,
-                            vp.position
-                        FROM vehicle_parts vp
-                        JOIN parts p ON vp.part_id = p.id
-                        JOIN part_groups pg ON p.group_id = pg.id
-                        JOIN part_categories pc ON pg.category_id = pc.id
-                        WHERE vp.model_year_engine_id IN (
-                            SELECT mye.id FROM model_year_engine mye
-                            JOIN models m ON mye.model_id = m.id
-                            JOIN brands b ON m.brand_id = b.id
-                            JOIN years y ON mye.year_id = y.id
-                            WHERE UPPER(b.name) = UPPER(?) AND UPPER(m.name) = UPPER(?) AND y.year = ?
-                        ) AND ({vp_where_sql})
-                        ORDER BY p.name
-                        LIMIT ?
-                    """, vp_params)
-
-                    for row in cursor.fetchall():
-                        results['vehicle_parts'].append({
-                            'id': row['id'],
-                            'oem_part_number': row['oem_part_number'],
-                            'name': row['name'],
-                            'name_es': row['name_es'],
-                            'image_url': row['image_url'],
-                            'group_name': row['group_name'],
-                            'group_id': row['group_id'],
-                            'category_name': row['category_name'],
-                            'category_id': row['category_id'],
-                            'quantity': row['quantity_required'],
-                            'position': row['position'],
-                            'match_type': 'vehicle_part'
-                        })
-
-                # If we found vehicle parts, return early with combined results
+                mv = matched_vehicle
+                vp_where_clauses = []
+                vp_params = {'mv_brand': mv['brand'], 'mv_model': mv['model'], 'mv_year': mv['year'], 'limit': limit}
+                for i, t in enumerate(remaining_terms):
+                    tp = f"%{t}%"
+                    vp_where_clauses.append(f"(p.name_part ILIKE :vp{i}_n OR p.name_es ILIKE :vp{i}_ne OR p.oem_part_number ILIKE :vp{i}_o OR pg.name_part_group ILIKE :vp{i}_g)")
+                    vp_params[f'vp{i}_n'] = tp
+                    vp_params[f'vp{i}_ne'] = tp
+                    vp_params[f'vp{i}_o'] = tp
+                    vp_params[f'vp{i}_g'] = tp
+                vp_where_sql = " AND ".join(vp_where_clauses)
+                rows = session.execute(text(f"""
+                    SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                           pg.name_part_group AS group_name, pg.id_part_group AS group_id,
+                           pc.name_part_category AS category_name, pc.id_part_category AS category_id,
+                           vp.quantity_required, pp.name_position_part AS position
+                    FROM vehicle_parts vp
+                    JOIN parts p ON vp.part_id = p.id_part
+                    JOIN part_groups pg ON p.group_id = pg.id_part_group
+                    JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                    LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+                    WHERE vp.model_year_engine_id IN (
+                        SELECT mye.id_mye FROM model_year_engine mye
+                        JOIN models m ON mye.model_id = m.id_model
+                        JOIN brands b ON m.brand_id = b.id_brand
+                        JOIN years y ON mye.year_id = y.id_year
+                        WHERE b.name_brand ILIKE :mv_brand AND m.name_model ILIKE :mv_model AND y.year_car = :mv_year
+                    ) AND ({vp_where_sql}) ORDER BY p.name_part LIMIT :limit
+                """), vp_params).mappings().all()
+                for r in rows:
+                    results['vehicle_parts'].append({'id': r['id'], 'oem_part_number': r['oem_part_number'],
+                        'name': r['name'], 'name_es': r['name_es'], 'image_url': None,
+                        'group_name': r['group_name'], 'group_id': r['group_id'],
+                        'category_name': r['category_name'], 'category_id': r['category_id'],
+                        'quantity': r['quantity_required'], 'position': r['position'], 'match_type': 'vehicle_part'})
                 if results['vehicle_parts']:
                     results['total_count'] = len(results['vehicle_parts'])
-                    conn.close()
                     return jsonify(results)
 
         # Search parts
-        if search_type in ('parts', 'all'):
-            # Split query into terms for multi-word search
-            terms = q.split()
-
-            # Build category filter
-            category_filter = ""
-            category_params = []
+        if search_type in ('parts', 'all') and terms:
+            where_clauses = []
+            params = {}
+            for i, t in enumerate(terms):
+                tp = f"%{t}%"
+                where_clauses.append(f"(p.name_part ILIKE :p{i}_n OR p.name_es ILIKE :p{i}_ne OR p.oem_part_number ILIKE :p{i}_o OR pg.name_part_group ILIKE :p{i}_g OR pc.name_part_category ILIKE :p{i}_c)")
+                params[f'p{i}_n'] = tp
+                params[f'p{i}_ne'] = tp
+                params[f'p{i}_o'] = tp
+                params[f'p{i}_g'] = tp
+                params[f'p{i}_c'] = tp
+            where_sql = " AND ".join(where_clauses)
+            cat_filter = ""
             if category_id:
-                category_filter = " AND pc.id = ?"
-                category_params = [category_id]
+                cat_filter = " AND pc.id_part_category = :cat_id"
+                params['cat_id'] = category_id
+            params['first_term'] = f"{terms[0]}%"
+            params['limit'] = limit
+            params['offset'] = offset
+            rows = session.execute(text(f"""
+                SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                       pg.name_part_group AS group_name, pc.name_part_category AS category_name
+                FROM parts p JOIN part_groups pg ON p.group_id = pg.id_part_group
+                JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                WHERE ({where_sql}){cat_filter}
+                ORDER BY CASE WHEN p.oem_part_number ILIKE :first_term THEN 1
+                              WHEN p.name_part ILIKE :first_term THEN 2 ELSE 3 END, p.name_part
+                LIMIT :limit OFFSET :offset
+            """), params).mappings().all()
+            for r in rows:
+                results['parts'].append({'id': r['id'], 'oem_part_number': r['oem_part_number'],
+                    'name': r['name'], 'name_es': r['name_es'], 'image_url': None,
+                    'group_name': r['group_name'], 'category_name': r['category_name'], 'match_type': 'oem'})
 
-            if terms:
-                # Build WHERE clause: each term must match at least one field
-                where_clauses = []
-                params = []
+            # Aftermarket search
+            if not category_id:
+                af_params = {'af_limit': limit, 'af_offset': offset}
+                af_clauses = []
+                for i, t in enumerate(terms):
+                    af_clauses.append(f"ap.part_number ILIKE :af{i}")
+                    af_params[f'af{i}'] = f"%{t}%"
+                af_rows = session.execute(text(f"""
+                    SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                           pg.name_part_group AS group_name, pc.name_part_category AS category_name,
+                           ap.part_number AS matched_number
+                    FROM aftermarket_parts ap JOIN parts p ON ap.oem_part_id = p.id_part
+                    JOIN part_groups pg ON p.group_id = pg.id_part_group
+                    JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                    WHERE {' AND '.join(af_clauses)} LIMIT :af_limit OFFSET :af_offset
+                """), af_params).mappings().all()
+                for r in af_rows:
+                    if not any(p['id'] == r['id'] for p in results['parts']):
+                        results['parts'].append({'id': r['id'], 'oem_part_number': r['oem_part_number'],
+                            'name': r['name'], 'name_es': r['name_es'], 'image_url': None,
+                            'group_name': r['group_name'], 'category_name': r['category_name'],
+                            'matched_number': r['matched_number'], 'match_type': 'aftermarket'})
 
-                for term in terms:
-                    term_pattern = f"%{term}%"
-                    where_clauses.append(
-                        "(p.name LIKE ? OR p.name_es LIKE ? OR p.oem_part_number LIKE ? OR pg.name LIKE ? OR pc.name LIKE ?)"
-                    )
-                    params.extend([term_pattern, term_pattern, term_pattern, term_pattern, term_pattern])
-
-                where_sql = " AND ".join(where_clauses)
-
-                # For ordering, use the first term
-                first_term = terms[0]
-                first_term_pattern = f"{first_term}%"
-
-                cursor.execute(f"""
-                    SELECT
-                        p.id,
-                        p.oem_part_number,
-                        p.name,
-                        p.name_es,
-                        p.image_url,
-                        pg.name AS group_name,
-                        pc.name AS category_name
-                    FROM parts p
-                    JOIN part_groups pg ON p.group_id = pg.id
-                    JOIN part_categories pc ON pg.category_id = pc.id
-                    WHERE ({where_sql}){category_filter}
-                    ORDER BY
-                        CASE
-                            WHEN p.oem_part_number LIKE ? THEN 1
-                            WHEN p.name LIKE ? THEN 2
-                            ELSE 3
-                        END,
-                        p.name
-                    LIMIT ? OFFSET ?
-                """, params + category_params + [first_term_pattern, first_term_pattern, limit, offset])
-
-                for row in cursor.fetchall():
-                    results['parts'].append({
-                        'id': row['id'],
-                        'oem_part_number': row['oem_part_number'],
-                        'name': row['name'],
-                        'name_es': row['name_es'],
-                        'image_url': row['image_url'],
-                        'group_name': row['group_name'],
-                        'category_name': row['category_name'],
-                        'match_type': 'oem'
-                    })
-
-            # Also search in aftermarket parts (only if no category filter)
-            if not category_id and terms:
-                # Build WHERE for aftermarket: match part numbers
-                af_where_clauses = []
-                af_params = []
-                for term in terms:
-                    af_where_clauses.append("ap.part_number LIKE ?")
-                    af_params.append(f"%{term}%")
-
-                af_where_sql = " AND ".join(af_where_clauses)
-                af_params.extend([limit, offset])
-
-                cursor.execute(f"""
-                    SELECT
-                        p.id,
-                        p.oem_part_number,
-                        p.name,
-                        p.name_es,
-                        p.image_url,
-                        pg.name AS group_name,
-                        pc.name AS category_name,
-                        ap.part_number AS matched_number
-                    FROM aftermarket_parts ap
-                    JOIN parts p ON ap.oem_part_id = p.id
-                    JOIN part_groups pg ON p.group_id = pg.id
-                    JOIN part_categories pc ON pg.category_id = pc.id
-                    WHERE {af_where_sql}
-                    LIMIT ? OFFSET ?
-                """, af_params)
-
-                for row in cursor.fetchall():
-                    # Avoid duplicates
-                    if not any(p['id'] == row['id'] for p in results['parts']):
-                        results['parts'].append({
-                            'id': row['id'],
-                            'oem_part_number': row['oem_part_number'],
-                            'name': row['name'],
-                            'name_es': row['name_es'],
-                            'image_url': row['image_url'],
-                            'group_name': row['group_name'],
-                            'category_name': row['category_name'],
-                            'matched_number': row['matched_number'],
-                            'match_type': 'aftermarket'
-                        })
-
-            # Search in cross-references
-            if terms:
-                cr_where_clauses = []
-                cr_params = []
-                for term in terms:
-                    cr_where_clauses.append("pcr.cross_reference_number LIKE ?")
-                    cr_params.append(f"%{term}%")
-
-                cr_where_sql = " AND ".join(cr_where_clauses)
-                cr_params.extend([limit, offset])
-
-                cursor.execute(f"""
-                    SELECT
-                        p.id,
-                        p.oem_part_number,
-                        p.name,
-                        p.name_es,
-                        p.image_url,
-                        pg.name AS group_name,
-                        pc.name AS category_name,
-                        pcr.cross_reference_number AS matched_number
-                    FROM part_cross_references pcr
-                    JOIN parts p ON pcr.part_id = p.id
-                    JOIN part_groups pg ON p.group_id = pg.id
-                    JOIN part_categories pc ON pg.category_id = pc.id
-                    WHERE {cr_where_sql}
-                    LIMIT ? OFFSET ?
-                """, cr_params)
-
-                for row in cursor.fetchall():
-                    # Avoid duplicates
-                    if not any(p['id'] == row['id'] for p in results['parts']):
-                        results['parts'].append({
-                            'id': row['id'],
-                            'oem_part_number': row['oem_part_number'],
-                            'name': row['name'],
-                            'name_es': row['name_es'],
-                            'image_url': row['image_url'],
-                            'group_name': row['group_name'],
-                            'category_name': row['category_name'],
-                            'matched_number': row['matched_number'],
-                            'match_type': 'cross_reference'
-                        })
+            # Cross-reference search
+            cr_params = {'cr_limit': limit, 'cr_offset': offset}
+            cr_clauses = []
+            for i, t in enumerate(terms):
+                cr_clauses.append(f"pcr.cross_reference_number ILIKE :cr{i}")
+                cr_params[f'cr{i}'] = f"%{t}%"
+            cr_rows = session.execute(text(f"""
+                SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                       pg.name_part_group AS group_name, pc.name_part_category AS category_name,
+                       pcr.cross_reference_number AS matched_number
+                FROM part_cross_references pcr JOIN parts p ON pcr.part_id = p.id_part
+                JOIN part_groups pg ON p.group_id = pg.id_part_group
+                JOIN part_categories pc ON pg.category_id = pc.id_part_category
+                WHERE {' AND '.join(cr_clauses)} LIMIT :cr_limit OFFSET :cr_offset
+            """), cr_params).mappings().all()
+            for r in cr_rows:
+                if not any(p['id'] == r['id'] for p in results['parts']):
+                    results['parts'].append({'id': r['id'], 'oem_part_number': r['oem_part_number'],
+                        'name': r['name'], 'name_es': r['name_es'], 'image_url': None,
+                        'group_name': r['group_name'], 'category_name': r['category_name'],
+                        'matched_number': r['matched_number'], 'match_type': 'cross_reference'})
 
         # Search vehicles
-        if search_type in ('vehicles', 'all'):
-            # Split query into terms for multi-word search
-            terms = q.split()
-
-            if terms:
-                # Build WHERE clause: each term must match at least one field
-                where_clauses = []
-                params = []
-
-                for term in terms:
-                    term_pattern = f"%{term}%"
-                    # Each term can match brand, model, year, or engine
-                    where_clauses.append(
-                        "(b.name LIKE ? OR m.name LIKE ? OR CAST(y.year AS TEXT) LIKE ? OR e.name LIKE ?)"
-                    )
-                    params.extend([term_pattern, term_pattern, term_pattern, term_pattern])
-
-                # All terms must match (AND between terms)
-                where_sql = " AND ".join(where_clauses)
-                params.extend([limit, offset])
-
-                cursor.execute(f"""
-                    SELECT
-                        mye.id,
-                        b.name AS brand,
-                        m.name AS model,
-                        y.year,
-                        e.name AS engine
-                    FROM model_year_engine mye
-                    JOIN models m ON mye.model_id = m.id
-                    JOIN brands b ON m.brand_id = b.id
-                    JOIN years y ON mye.year_id = y.id
-                    JOIN engines e ON mye.engine_id = e.id
-                    WHERE {where_sql}
-                    ORDER BY y.year DESC, b.name, m.name
-                    LIMIT ? OFFSET ?
-                """, params)
-
-                for row in cursor.fetchall():
-                    results['vehicles'].append({
-                        'id': row['id'],
-                        'brand': row['brand'],
-                        'model': row['model'],
-                        'year': row['year'],
-                        'engine': row['engine']
-                    })
+        if search_type in ('vehicles', 'all') and terms:
+            v_params = {'v_limit': limit, 'v_offset': offset}
+            v_clauses = []
+            for i, t in enumerate(terms):
+                tp = f"%{t}%"
+                v_clauses.append(f"(b.name_brand ILIKE :v{i}_b OR m.name_model ILIKE :v{i}_m OR CAST(y.year_car AS TEXT) ILIKE :v{i}_y OR e.name_engine ILIKE :v{i}_e)")
+                v_params[f'v{i}_b'] = tp
+                v_params[f'v{i}_m'] = tp
+                v_params[f'v{i}_y'] = tp
+                v_params[f'v{i}_e'] = tp
+            v_rows = session.execute(text(f"""
+                SELECT mye.id_mye AS id, b.name_brand AS brand, m.name_model AS model,
+                       y.year_car AS year, e.name_engine AS engine
+                FROM model_year_engine mye
+                JOIN models m ON mye.model_id = m.id_model JOIN brands b ON m.brand_id = b.id_brand
+                JOIN years y ON mye.year_id = y.id_year JOIN engines e ON mye.engine_id = e.id_engine
+                WHERE {' AND '.join(v_clauses)}
+                ORDER BY y.year_car DESC, b.name_brand, m.name_model
+                LIMIT :v_limit OFFSET :v_offset
+            """), v_params).mappings().all()
+            for r in v_rows:
+                results['vehicles'].append({'id': r['id'], 'brand': r['brand'], 'model': r['model'],
+                                            'year': r['year'], 'engine': r['engine']})
 
         results['total_count'] = len(results['parts']) + len(results['vehicles'])
-        conn.close()
         return jsonify(results)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/search/parts')
 def api_search_parts():
-    """Full-text search in parts catalog with pagination"""
+    session = Session()
     try:
         q = request.args.get('q', '').strip()
         category_id = request.args.get('category_id', type=int)
         group_id = request.args.get('group_id', type=int)
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)  # Max 100 per page
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
         offset = (page - 1) * per_page
-
         if not q:
             return jsonify({'error': 'Search query is required'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Check if FTS5 table exists
-        cursor.execute("""
-            SELECT name FROM sqlite_master
-            WHERE type='table' AND name='parts_fts'
-        """)
-        fts_exists = cursor.fetchone() is not None
-
-        parts = []
-        total_count = 0
-
-        if fts_exists:
-            # Use FTS5 for full-text search
-            # Escape special FTS5 characters (-, *, ^, etc.) by quoting each term
-            terms = q.split()
-            quoted_terms = []
-            for term in terms:
-                # Escape double quotes and wrap in quotes to prevent FTS operators
-                escaped_term = term.replace('"', '""')
-                quoted_terms.append(f'"{escaped_term}"')
-            fts_query = ' '.join(quoted_terms)
-
-            # Build filter conditions
-            filter_clause = ""
-            filter_params = []
-
-            if category_id:
-                filter_clause += " AND pg.category_id = ?"
-                filter_params.append(category_id)
-
-            if group_id:
-                filter_clause += " AND p.group_id = ?"
-                filter_params.append(group_id)
-
-            # Get total count for FTS search
-            count_query = """
-                SELECT COUNT(*) as total
-                FROM parts_fts
-                JOIN parts p ON parts_fts.rowid = p.id
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE parts_fts MATCH ?
-            """ + filter_clause
-            cursor.execute(count_query, [fts_query] + filter_params)
-            total_count = cursor.fetchone()['total']
-
-            # Get paginated data
-            data_query = """
-                SELECT
-                    p.id,
-                    p.oem_part_number,
-                    p.name,
-                    p.name_es,
-                    p.description,
-                    pg.name AS group_name,
-                    pc.name AS category_name,
-                    bm25(parts_fts) AS rank
-                FROM parts_fts
-                JOIN parts p ON parts_fts.rowid = p.id
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE parts_fts MATCH ?
-            """ + filter_clause + " ORDER BY rank LIMIT ? OFFSET ?"
-
-            cursor.execute(data_query, [fts_query] + filter_params + [per_page, offset])
-
-            for row in cursor.fetchall():
-                parts.append({
-                    'id': row['id'],
-                    'oem_part_number': row['oem_part_number'],
-                    'name': row['name'],
-                    'name_es': row['name_es'],
-                    'description': row['description'],
-                    'group_name': row['group_name'],
-                    'category_name': row['category_name'],
-                    'rank': row['rank']
-                })
-        else:
-            # Fallback to LIKE search if FTS5 table doesn't exist
-            search_term = f"%{q}%"
-
-            # Build filter conditions
-            filter_clause = ""
-            filter_params = []
-
-            if category_id:
-                filter_clause += " AND pg.category_id = ?"
-                filter_params.append(category_id)
-
-            if group_id:
-                filter_clause += " AND p.group_id = ?"
-                filter_params.append(group_id)
-
-            # Get total count for LIKE search
-            count_query = """
-                SELECT COUNT(*) as total
-                FROM parts p
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE (p.name LIKE ? OR p.name_es LIKE ? OR p.oem_part_number LIKE ?
-                    OR p.description LIKE ?)
-            """ + filter_clause
-            cursor.execute(count_query, [search_term, search_term, search_term, search_term] + filter_params)
-            total_count = cursor.fetchone()['total']
-
-            # Get paginated data
-            data_query = """
-                SELECT
-                    p.id,
-                    p.oem_part_number,
-                    p.name,
-                    p.name_es,
-                    p.description,
-                    pg.name AS group_name,
-                    pc.name AS category_name
-                FROM parts p
-                JOIN part_groups pg ON p.group_id = pg.id
-                JOIN part_categories pc ON pg.category_id = pc.id
-                WHERE (p.name LIKE ? OR p.name_es LIKE ? OR p.oem_part_number LIKE ?
-                    OR p.description LIKE ?)
-            """ + filter_clause + " ORDER BY p.name LIMIT ? OFFSET ?"
-
-            cursor.execute(data_query, [search_term, search_term, search_term, search_term] + filter_params + [per_page, offset])
-
-            for row in cursor.fetchall():
-                parts.append({
-                    'id': row['id'],
-                    'oem_part_number': row['oem_part_number'],
-                    'name': row['name'],
-                    'name_es': row['name_es'],
-                    'description': row['description'],
-                    'group_name': row['group_name'],
-                    'category_name': row['category_name'],
-                    'rank': 0
-                })
-
-        conn.close()
-
+        filter_clause = ""
+        params = {'q': q, 'per_page': per_page, 'offset': offset}
+        if category_id:
+            filter_clause += " AND pg.category_id = :cid"
+            params['cid'] = category_id
+        if group_id:
+            filter_clause += " AND p.group_id = :gid"
+            params['gid'] = group_id
+        total_count = session.execute(text(f"""
+            SELECT COUNT(*) AS total FROM parts p
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE p.search_vector @@ plainto_tsquery('spanish', :q) {filter_clause}
+        """), params).mappings().first()['total']
+        rows = session.execute(text(f"""
+            SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es,
+                   p.description, pg.name_part_group AS group_name, pc.name_part_category AS category_name,
+                   ts_rank(p.search_vector, plainto_tsquery('spanish', :q)) AS rank
+            FROM parts p JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE p.search_vector @@ plainto_tsquery('spanish', :q) {filter_clause}
+            ORDER BY rank DESC LIMIT :per_page OFFSET :offset
+        """), params).mappings().all()
+        parts = [{'id': r['id'], 'oem_part_number': r['oem_part_number'], 'name': r['name'],
+                   'name_es': r['name_es'], 'description': r['description'],
+                   'group_name': r['group_name'], 'category_name': r['category_name'],
+                   'rank': float(r['rank'])} for r in rows]
         total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': parts,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        return jsonify({'data': parts, 'pagination': {'page': page, 'per_page': per_page,
+                        'total': total_count, 'total_pages': total_pages}})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/vin/decode/<vin>')
 def api_vin_decode(vin):
-    """Decode a VIN using NHTSA API with caching"""
+    session = Session()
     try:
         vin = vin.upper().strip()
-
-        # Validate VIN format
         if not validate_vin(vin):
-            return jsonify({
-                'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'
-            }), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Check if vin_cache table exists
-        cursor.execute("""
-            SELECT name FROM sqlite_master
-            WHERE type='table' AND name='vin_cache'
-        """)
-        cache_exists = cursor.fetchone() is not None
-
-        cached_data = None
-        if cache_exists:
-            # Check for cached VIN data that hasn't expired
-            cursor.execute("""
-                SELECT
-                    vin, make, model, year, engine_info,
-                    body_class, drive_type,
-                    model_year_engine_id, created_at, expires_at
-                FROM vin_cache
-                WHERE vin = ? AND expires_at > datetime('now')
-            """, (vin,))
-            cached_row = cursor.fetchone()
-
-            if cached_row:
-                # Parse engine_info JSON if it exists
-                engine_info_data = {}
-                if cached_row['engine_info']:
-                    try:
-                        engine_info_data = json_module.loads(cached_row['engine_info'])
-                    except:
-                        engine_info_data = {'raw': cached_row['engine_info']}
-
-                cached_data = {
-                    'vin': cached_row['vin'],
-                    'make': cached_row['make'],
-                    'model': cached_row['model'],
-                    'year': cached_row['year'],
-                    'engine_info': engine_info_data,
-                    'body_class': cached_row['body_class'],
-                    'drive_type': cached_row['drive_type'],
-                    'matched_vehicle': None,
-                    'cached': True
-                }
-
-                # Get matched vehicle info if available
-                if cached_row['model_year_engine_id']:
-                    cursor.execute("""
-                        SELECT
-                            mye.id,
-                            b.name AS brand,
-                            m.name AS model,
-                            y.year,
-                            e.name AS engine
-                        FROM model_year_engine mye
-                        JOIN models m ON mye.model_id = m.id
-                        JOIN brands b ON m.brand_id = b.id
-                        JOIN years y ON mye.year_id = y.id
-                        JOIN engines e ON mye.engine_id = e.id
-                        WHERE mye.id = ?
-                    """, (cached_row['model_year_engine_id'],))
-                    mye_row = cursor.fetchone()
-                    if mye_row:
-                        cached_data['matched_vehicle'] = {
-                            'mye_id': mye_row['id'],
-                            'brand': mye_row['brand'],
-                            'model': mye_row['model'],
-                            'year': mye_row['year'],
-                            'engine': mye_row['engine']
-                        }
-
-                conn.close()
-                return jsonify(cached_data)
-
+            return jsonify({'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'}), 400
+        cached_row = session.execute(text("""
+            SELECT vin, make, model, year, engine_info, body_class, drive_type,
+                   model_year_engine_id, created_at, expires_at
+            FROM vin_cache WHERE vin = :vin AND expires_at > NOW()
+        """), {'vin': vin}).mappings().first()
+        if cached_row:
+            engine_info_data = {}
+            if cached_row['engine_info']:
+                try:
+                    engine_info_data = json_module.loads(cached_row['engine_info'])
+                except Exception:
+                    engine_info_data = {'raw': cached_row['engine_info']}
+            cached_data = {'vin': cached_row['vin'], 'make': cached_row['make'],
+                           'model': cached_row['model'], 'year': cached_row['year'],
+                           'engine_info': engine_info_data, 'body_class': cached_row['body_class'],
+                           'drive_type': cached_row['drive_type'], 'matched_vehicle': None, 'cached': True}
+            if cached_row['model_year_engine_id']:
+                mye_row = session.execute(text("""
+                    SELECT mye.id_mye AS id, b.name_brand AS brand, m.name_model AS model,
+                           y.year_car AS year, e.name_engine AS engine
+                    FROM model_year_engine mye
+                    JOIN models m ON mye.model_id = m.id_model JOIN brands b ON m.brand_id = b.id_brand
+                    JOIN years y ON mye.year_id = y.id_year JOIN engines e ON mye.engine_id = e.id_engine
+                    WHERE mye.id_mye = :mye_id
+                """), {'mye_id': cached_row['model_year_engine_id']}).mappings().first()
+                if mye_row:
+                    cached_data['matched_vehicle'] = {'mye_id': mye_row['id'], 'brand': mye_row['brand'],
+                        'model': mye_row['model'], 'year': mye_row['year'], 'engine': mye_row['engine']}
+            return jsonify(cached_data)
         # Call NHTSA API
         nhtsa_url = f'https://vpic.nhtsa.dot.gov/api/vehicles/DecodeVin/{vin}?format=json'
-
         try:
-            req = urllib.request.Request(nhtsa_url, headers={'User-Agent': 'AutopartesDB/1.0'})
+            req = urllib.request.Request(nhtsa_url, headers={'User-Agent': 'NexusAutoparts/2.0'})
             with urllib.request.urlopen(req, timeout=10) as response:
                 nhtsa_data = json_module.loads(response.read().decode('utf-8'))
         except urllib.error.URLError as e:
-            conn.close()
             return jsonify({'error': f'Failed to connect to NHTSA API: {str(e)}'}), 503
         except urllib.error.HTTPError as e:
-            conn.close()
             return jsonify({'error': f'NHTSA API error: {e.code}'}), 502
         except Exception as e:
-            conn.close()
             return jsonify({'error': f'Error calling NHTSA API: {str(e)}'}), 500
-
-        # Parse NHTSA response
-        results = {item['Variable']: item['Value'] for item in nhtsa_data.get('Results', [])}
-
-        # Extract relevant fields
-        make = results.get('Make', '')
-        model = results.get('Model', '')
-        year_str = results.get('ModelYear', '')
+        nhtsa_results = {item['Variable']: item['Value'] for item in nhtsa_data.get('Results', [])}
+        make = nhtsa_results.get('Make', '')
+        model = nhtsa_results.get('Model', '')
+        year_str = nhtsa_results.get('ModelYear', '')
         year = int(year_str) if year_str and year_str.isdigit() else None
-        engine_config = results.get('EngineConfiguration', '')
-        cylinders_str = results.get('EngineCylinders', '')
+        engine_config = nhtsa_results.get('EngineConfiguration', '')
+        cylinders_str = nhtsa_results.get('EngineCylinders', '')
         cylinders = int(cylinders_str) if cylinders_str and cylinders_str.isdigit() else None
-        displacement_str = results.get('DisplacementL', '')
+        displacement_str = nhtsa_results.get('DisplacementL', '')
         displacement_l = float(displacement_str) if displacement_str else None
-        fuel_type = results.get('FuelTypePrimary', '')
-        body_class = results.get('BodyClass', '')
-        drive_type = results.get('DriveType', '')
-
-        # Try to match to model_year_engine record
+        fuel_type = nhtsa_results.get('FuelTypePrimary', '')
+        body_class = nhtsa_results.get('BodyClass', '')
+        drive_type = nhtsa_results.get('DriveType', '')
         matched_mye_id = None
         matched_vehicle = None
-
         if make and model and year:
-            cursor.execute("""
-                SELECT
-                    mye.id,
-                    b.name AS brand,
-                    m.name AS model,
-                    y.year,
-                    e.name AS engine
+            mye_row = session.execute(text("""
+                SELECT mye.id_mye AS id, b.name_brand AS brand, m.name_model AS model,
+                       y.year_car AS year, e.name_engine AS engine
                 FROM model_year_engine mye
-                JOIN models m ON mye.model_id = m.id
-                JOIN brands b ON m.brand_id = b.id
-                JOIN years y ON mye.year_id = y.id
-                JOIN engines e ON mye.engine_id = e.id
-                WHERE UPPER(b.name) = UPPER(?)
-                  AND UPPER(m.name) = UPPER(?)
-                  AND y.year = ?
-                LIMIT 1
-            """, (make, model, year))
-
-            mye_row = cursor.fetchone()
+                JOIN models m ON mye.model_id = m.id_model JOIN brands b ON m.brand_id = b.id_brand
+                JOIN years y ON mye.year_id = y.id_year JOIN engines e ON mye.engine_id = e.id_engine
+                WHERE b.name_brand ILIKE :make AND m.name_model ILIKE :model AND y.year_car = :year LIMIT 1
+            """), {'make': make, 'model': model, 'year': year}).mappings().first()
             if mye_row:
                 matched_mye_id = mye_row['id']
-                matched_vehicle = {
-                    'mye_id': mye_row['id'],
-                    'brand': mye_row['brand'],
-                    'model': mye_row['model'],
-                    'year': mye_row['year'],
-                    'engine': mye_row['engine']
-                }
-
-        # Store in cache with 30-day expiry
-        if cache_exists:
-            expires_at = (datetime.now() + timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')
-            # Combine engine info into JSON
-            engine_info = json_module.dumps({
-                'configuration': engine_config,
-                'cylinders': cylinders,
-                'displacement_l': displacement_l,
-                'fuel_type': fuel_type
-            })
-            cursor.execute("""
-                INSERT OR REPLACE INTO vin_cache
-                (vin, decoded_data, make, model, year, engine_info,
+                matched_vehicle = {'mye_id': mye_row['id'], 'brand': mye_row['brand'],
+                    'model': mye_row['model'], 'year': mye_row['year'], 'engine': mye_row['engine']}
+        expires_at = datetime.now() + timedelta(days=30)
+        engine_info = json_module.dumps({'configuration': engine_config, 'cylinders': cylinders,
+                                         'displacement_l': displacement_l, 'fuel_type': fuel_type})
+        session.execute(text("""
+            INSERT INTO vin_cache (vin, decoded_data, make, model, year, engine_info,
                  body_class, drive_type, model_year_engine_id, expires_at)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (vin, json_module.dumps(results), make, model, year, engine_info,
-                  body_class, drive_type, matched_mye_id, expires_at))
-            conn.commit()
-
-        result = {
-            'vin': vin,
-            'make': make,
-            'model': model,
-            'year': year,
-            'engine_info': {
-                'configuration': engine_config,
-                'cylinders': cylinders,
-                'displacement_l': displacement_l,
-                'fuel_type': fuel_type
-            },
-            'body_class': body_class,
-            'drive_type': drive_type,
-            'matched_vehicle': matched_vehicle,
-            'cached': False
-        }
-
-        conn.close()
-        return jsonify(result)
+            VALUES (:vin, :decoded_data::jsonb, :make, :model, :year, :engine_info,
+                    :body_class, :drive_type, :mye_id, :expires_at)
+            ON CONFLICT (vin) DO UPDATE SET
+                decoded_data = EXCLUDED.decoded_data, make = EXCLUDED.make, model = EXCLUDED.model,
+                year = EXCLUDED.year, engine_info = EXCLUDED.engine_info, body_class = EXCLUDED.body_class,
+                drive_type = EXCLUDED.drive_type, model_year_engine_id = EXCLUDED.model_year_engine_id,
+                expires_at = EXCLUDED.expires_at
+        """), {'vin': vin, 'decoded_data': json_module.dumps(nhtsa_results), 'make': make,
+               'model': model, 'year': year, 'engine_info': engine_info, 'body_class': body_class,
+               'drive_type': drive_type, 'mye_id': matched_mye_id, 'expires_at': expires_at})
+        session.commit()
+        return jsonify({'vin': vin, 'make': make, 'model': model, 'year': year,
+                        'engine_info': {'configuration': engine_config, 'cylinders': cylinders,
+                                        'displacement_l': displacement_l, 'fuel_type': fuel_type},
+                        'body_class': body_class, 'drive_type': drive_type,
+                        'matched_vehicle': matched_vehicle, 'cached': False})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/vin/<vin>/parts')
 def api_vin_parts(vin):
-    """Get parts for a decoded VIN"""
+    session = Session()
     try:
         vin = vin.upper().strip()
-
         if not validate_vin(vin):
-            return jsonify({
-                'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'
-            }), 400
-
+            return jsonify({'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'}), 400
         category_id = request.args.get('category_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Check if vin_cache table exists
-        cursor.execute("""
-            SELECT name FROM sqlite_master
-            WHERE type='table' AND name='vin_cache'
-        """)
-        cache_exists = cursor.fetchone() is not None
-
-        if not cache_exists:
-            conn.close()
-            return jsonify({
-                'error': 'VIN cache not available. Please decode the VIN first.'
-            }), 400
-
-        # Look up VIN in cache
-        cursor.execute("""
-            SELECT
-                vin, make, model, year, model_year_engine_id
-            FROM vin_cache
-            WHERE vin = ?
-        """, (vin,))
-        cached_row = cursor.fetchone()
-
+        cached_row = session.execute(text("SELECT vin, make, model, year, model_year_engine_id FROM vin_cache WHERE vin = :vin"), {'vin': vin}).mappings().first()
         if not cached_row:
-            conn.close()
-            return jsonify({
-                'error': 'VIN not found in cache. Please decode the VIN first using /api/vin/decode/<vin>'
-            }), 404
-
+            return jsonify({'error': 'VIN not found in cache. Please decode the VIN first using /api/vin/decode/<vin>'}), 404
         mye_id = cached_row['model_year_engine_id']
-
-        vehicle_info = {
-            'vin': cached_row['vin'],
-            'make': cached_row['make'],
-            'model': cached_row['model'],
-            'year': cached_row['year'],
-            'mye_id': mye_id
-        }
-
+        vehicle_info = {'vin': cached_row['vin'], 'make': cached_row['make'], 'model': cached_row['model'],
+                        'year': cached_row['year'], 'mye_id': mye_id}
         if not mye_id:
-            conn.close()
-            return jsonify({
-                'vin': vin,
-                'vehicle_info': vehicle_info,
-                'categories': [],
-                'message': 'No matching vehicle configuration found in database. Use /api/vin/<vin>/match to manually link.'
-            })
-
-        # Get parts for this vehicle grouped by category
-        query = """
-            SELECT
-                pc.id AS category_id,
-                pc.name AS category_name,
-                pc.name_es AS category_name_es,
-                p.id AS part_id,
-                p.oem_part_number,
-                p.name AS part_name,
-                p.name_es AS part_name_es,
-                pg.name AS group_name,
-                vp.quantity_required,
-                vp.position
-            FROM vehicle_parts vp
-            JOIN parts p ON vp.part_id = p.id
-            JOIN part_groups pg ON p.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE vp.model_year_engine_id = ?
-        """
-        params = [mye_id]
-
+            return jsonify({'vin': vin, 'vehicle_info': vehicle_info, 'categories': [],
+                            'message': 'No matching vehicle configuration found in database. Use /api/vin/<vin>/match to manually link.'})
+        params = {'mye_id': mye_id}
+        cat_filter = ""
         if category_id:
-            query += " AND pc.id = ?"
-            params.append(category_id)
-
-        query += " ORDER BY pc.display_order, pg.display_order, p.name"
-
-        cursor.execute(query, params)
-
-        # Group parts by category
+            cat_filter = " AND pc.id_part_category = :cid"
+            params['cid'] = category_id
+        rows = session.execute(text(f"""
+            SELECT pc.id_part_category AS category_id, pc.name_part_category AS category_name,
+                   pc.name_es AS category_name_es, p.id_part AS part_id, p.oem_part_number,
+                   p.name_part AS part_name, p.name_es AS part_name_es,
+                   pg.name_part_group AS group_name, vp.quantity_required,
+                   pp.name_position_part AS position
+            FROM vehicle_parts vp JOIN parts p ON vp.part_id = p.id_part
+            JOIN part_groups pg ON p.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+            WHERE vp.model_year_engine_id = :mye_id {cat_filter}
+            ORDER BY pc.display_order, pg.display_order, p.name_part
+        """), params).mappings().all()
         categories_dict = {}
-        for row in cursor.fetchall():
-            cat_id = row['category_id']
-            if cat_id not in categories_dict:
-                categories_dict[cat_id] = {
-                    'id': cat_id,
-                    'name': row['category_name'],
-                    'name_es': row['category_name_es'],
-                    'parts': []
-                }
-
-            categories_dict[cat_id]['parts'].append({
-                'id': row['part_id'],
-                'oem_part_number': row['oem_part_number'],
-                'name': row['part_name'],
-                'name_es': row['part_name_es'],
-                'group_name': row['group_name'],
-                'quantity_required': row['quantity_required'],
-                'position': row['position']
-            })
-
-        conn.close()
-
-        return jsonify({
-            'vin': vin,
-            'vehicle_info': vehicle_info,
-            'categories': list(categories_dict.values())
-        })
+        for r in rows:
+            cid = r['category_id']
+            if cid not in categories_dict:
+                categories_dict[cid] = {'id': cid, 'name': r['category_name'], 'name_es': r['category_name_es'], 'parts': []}
+            categories_dict[cid]['parts'].append({'id': r['part_id'], 'oem_part_number': r['oem_part_number'],
+                'name': r['part_name'], 'name_es': r['part_name_es'], 'group_name': r['group_name'],
+                'quantity_required': r['quantity_required'], 'position': r['position']})
+        return jsonify({'vin': vin, 'vehicle_info': vehicle_info, 'categories': list(categories_dict.values())})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/vin/<vin>/match')
 def api_vin_match(vin):
-    """Manually match a VIN to a vehicle configuration"""
+    session = Session()
     try:
         vin = vin.upper().strip()
-
         if not validate_vin(vin):
-            return jsonify({
-                'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'
-            }), 400
-
+            return jsonify({'error': 'Invalid VIN format. VIN must be 17 alphanumeric characters (no I, O, Q).'}), 400
         mye_id = request.args.get('mye_id', type=int)
-
         if not mye_id:
             return jsonify({'error': 'mye_id parameter is required'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Check if vin_cache table exists
-        cursor.execute("""
-            SELECT name FROM sqlite_master
-            WHERE type='table' AND name='vin_cache'
-        """)
-        cache_exists = cursor.fetchone() is not None
-
-        if not cache_exists:
-            conn.close()
-            return jsonify({
-                'error': 'VIN cache table not available.'
-            }), 400
-
-        # Verify the mye_id exists
-        cursor.execute("""
-            SELECT id FROM model_year_engine WHERE id = ?
-        """, (mye_id,))
-        if not cursor.fetchone():
-            conn.close()
+        mye_row = session.execute(text("SELECT id_mye FROM model_year_engine WHERE id_mye = :mid"), {'mid': mye_id}).mappings().first()
+        if not mye_row:
             return jsonify({'error': f'model_year_engine_id {mye_id} not found'}), 404
-
-        # Check if VIN exists in cache
-        cursor.execute("""
-            SELECT vin FROM vin_cache WHERE vin = ?
-        """, (vin,))
-        vin_exists = cursor.fetchone() is not None
-
-        if vin_exists:
-            # Update existing cache entry
-            cursor.execute("""
-                UPDATE vin_cache
-                SET model_year_engine_id = ?
-                WHERE vin = ?
-            """, (mye_id, vin))
+        vin_row = session.execute(text("SELECT vin FROM vin_cache WHERE vin = :vin"), {'vin': vin}).mappings().first()
+        if vin_row:
+            session.execute(text("UPDATE vin_cache SET model_year_engine_id = :mid WHERE vin = :vin"), {'mid': mye_id, 'vin': vin})
         else:
-            # Create new cache entry with minimal info
-            expires_at = (datetime.now() + timedelta(days=30)).strftime('%Y-%m-%d %H:%M:%S')
-            cursor.execute("""
-                INSERT INTO vin_cache
-                (vin, model_year_engine_id, cached_at, expires_at)
-                VALUES (?, ?, datetime('now'), ?)
-            """, (vin, mye_id, expires_at))
-
-        conn.commit()
-        conn.close()
-
-        return jsonify({
-            'success': True,
-            'vin': vin,
-            'mye_id': mye_id
-        })
+            expires_at = datetime.now() + timedelta(days=30)
+            session.execute(text("""
+                INSERT INTO vin_cache (vin, decoded_data, model_year_engine_id, created_at, expires_at)
+                VALUES (:vin, '{}'::jsonb, :mid, NOW(), :expires_at)
+            """), {'vin': vin, 'mid': mye_id, 'expires_at': expires_at})
+        session.commit()
+        return jsonify({'success': True, 'vin': vin, 'mye_id': mye_id})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ============================================================================
-# ADMIN API ENDPOINTS - CRUD Operations
+# Admin Endpoints
 # ============================================================================
 
 @app.route('/api/admin/stats')
 def api_admin_stats():
-    """Get statistics for admin dashboard"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         stats = {}
-
-        # Count categories
-        cursor.execute("SELECT COUNT(*) FROM part_categories")
-        stats['categories'] = cursor.fetchone()[0]
-
-        # Count groups
-        cursor.execute("SELECT COUNT(*) FROM part_groups")
-        stats['groups'] = cursor.fetchone()[0]
-
-        # Count parts
-        cursor.execute("SELECT COUNT(*) FROM parts")
-        stats['parts'] = cursor.fetchone()[0]
-
-        # Count aftermarket parts
-        cursor.execute("SELECT COUNT(*) FROM aftermarket_parts")
-        stats['aftermarket'] = cursor.fetchone()[0]
-
-        # Count manufacturers
-        cursor.execute("SELECT COUNT(*) FROM manufacturers")
-        stats['manufacturers'] = cursor.fetchone()[0]
-
-        # Count fitments
-        cursor.execute("SELECT COUNT(*) FROM vehicle_parts")
-        stats['fitment'] = cursor.fetchone()[0]
-
-        conn.close()
+        for table, key in [('part_categories', 'categories'), ('part_groups', 'groups'),
+                           ('parts', 'parts'), ('aftermarket_parts', 'aftermarket'),
+                           ('manufacturers', 'manufacturers'), ('vehicle_parts', 'fitment')]:
+            stats[key] = session.execute(text(f"SELECT COUNT(*) FROM {table}")).scalar()
         return jsonify(stats)
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Categories CRUD ----
 
 @app.route('/api/admin/categories', methods=['POST'])
 def api_admin_create_category():
-    """Create a new category"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO part_categories (name, name_es, slug, icon_name, display_order, parent_id)
-            VALUES (?, ?, ?, ?, ?, ?)
-        """, (
-            data['name'],
-            data.get('name_es'),
-            data.get('slug') or data['name'].lower().replace(' ', '-'),
-            data.get('icon_name'),
-            data.get('display_order', 0),
-            data.get('parent_id')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO part_categories (name_part_category, name_es, slug, icon_name, display_order, parent_id)
+            VALUES (:name, :name_es, :slug, :icon_name, :display_order, :parent_id)
+            RETURNING id_part_category
+        """), {'name': data['name'], 'name_es': data.get('name_es'),
+               'slug': data.get('slug') or data['name'].lower().replace(' ', '-'),
+               'icon_name': data.get('icon_name'), 'display_order': data.get('display_order', 0),
+               'parent_id': data.get('parent_id')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Category created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/categories/<int:category_id>', methods=['PUT'])
 def api_admin_update_category(category_id):
-    """Update a category"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE part_categories
-            SET name = ?, name_es = ?, slug = ?, icon_name = ?, display_order = ?
-            WHERE id = ?
-        """, (
-            data['name'],
-            data.get('name_es'),
-            data.get('slug'),
-            data.get('icon_name'),
-            data.get('display_order', 0),
-            category_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE part_categories SET name_part_category = :name, name_es = :name_es,
+                   slug = :slug, icon_name = :icon_name, display_order = :display_order
+            WHERE id_part_category = :id
+        """), {'name': data['name'], 'name_es': data.get('name_es'), 'slug': data.get('slug'),
+               'icon_name': data.get('icon_name'), 'display_order': data.get('display_order', 0),
+               'id': category_id})
+        session.commit()
         return jsonify({'message': 'Category updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/categories/<int:category_id>', methods=['DELETE'])
 def api_admin_delete_category(category_id):
-    """Delete a category"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM part_categories WHERE id = ?", (category_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM part_categories WHERE id_part_category = :id"), {'id': category_id})
+        session.commit()
         return jsonify({'message': 'Category deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Groups CRUD ----
 
 @app.route('/api/admin/groups')
 def api_admin_list_groups():
-    """List all groups with category info"""
+    session = Session()
     try:
         category_id = request.args.get('category_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT pg.id, pg.name, pg.name_es, pg.category_id, pg.display_order, pg.slug,
-                   pc.name AS category_name
+        q = """
+            SELECT pg.id_part_group AS id, pg.name_part_group AS name, pg.name_es,
+                   pg.category_id, pg.display_order, pg.slug,
+                   pc.name_part_category AS category_name
             FROM part_groups pg
-            LEFT JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE 1=1
+            LEFT JOIN part_categories pc ON pg.category_id = pc.id_part_category WHERE 1=1
         """
-        params = []
-
+        params = {}
         if category_id:
-            query += " AND pg.category_id = ?"
-            params.append(category_id)
-
-        query += " ORDER BY pg.display_order, pg.name"
-
-        cursor.execute(query, params)
-
-        groups = []
-        for row in cursor.fetchall():
-            groups.append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'category_id': row['category_id'],
-                'category_name': row['category_name'],
-                'display_order': row['display_order'],
-                'slug': row['slug']
-            })
-
-        conn.close()
-        return jsonify(groups)
+            q += " AND pg.category_id = :cid"
+            params['cid'] = category_id
+        q += " ORDER BY pg.display_order, pg.name_part_group"
+        rows = session.execute(text(q), params).mappings().all()
+        return jsonify([{'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                         'category_id': r['category_id'], 'category_name': r['category_name'],
+                         'display_order': r['display_order'], 'slug': r['slug']} for r in rows])
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/groups', methods=['POST'])
 def api_admin_create_group():
-    """Create a new group"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO part_groups (category_id, name, name_es, slug, display_order)
-            VALUES (?, ?, ?, ?, ?)
-        """, (
-            data['category_id'],
-            data['name'],
-            data.get('name_es'),
-            data.get('slug') or data['name'].lower().replace(' ', '-'),
-            data.get('display_order', 0)
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO part_groups (category_id, name_part_group, name_es, slug, display_order)
+            VALUES (:category_id, :name, :name_es, :slug, :display_order)
+            RETURNING id_part_group
+        """), {'category_id': data['category_id'], 'name': data['name'],
+               'name_es': data.get('name_es'),
+               'slug': data.get('slug') or data['name'].lower().replace(' ', '-'),
+               'display_order': data.get('display_order', 0)})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Group created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/groups/<int:group_id>', methods=['PUT'])
 def api_admin_update_group(group_id):
-    """Update a group"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE part_groups
-            SET category_id = ?, name = ?, name_es = ?, display_order = ?
-            WHERE id = ?
-        """, (
-            data['category_id'],
-            data['name'],
-            data.get('name_es'),
-            data.get('display_order', 0),
-            group_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE part_groups SET category_id = :category_id, name_part_group = :name,
+                   name_es = :name_es, display_order = :display_order
+            WHERE id_part_group = :id
+        """), {'category_id': data['category_id'], 'name': data['name'],
+               'name_es': data.get('name_es'), 'display_order': data.get('display_order', 0),
+               'id': group_id})
+        session.commit()
         return jsonify({'message': 'Group updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/groups/<int:group_id>', methods=['DELETE'])
 def api_admin_delete_group(group_id):
-    """Delete a group"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM part_groups WHERE id = ?", (group_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM part_groups WHERE id_part_group = :id"), {'id': group_id})
+        session.commit()
         return jsonify({'message': 'Group deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Parts CRUD ----
 
 @app.route('/api/admin/parts', methods=['POST'])
 def api_admin_create_part():
-    """Create a new OEM part"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO parts (oem_part_number, name, name_es, group_id, description, description_es, weight_kg, material, image_url)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-        """, (
-            data['oem_part_number'],
-            data['name'],
-            data.get('name_es'),
-            data['group_id'],
-            data.get('description'),
-            data.get('description_es'),
-            data.get('weight_kg'),
-            data.get('material'),
-            data.get('image_url')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO parts (oem_part_number, name_part, name_es, group_id, description,
+                               description_es, weight_kg, id_material)
+            VALUES (:oem, :name, :name_es, :group_id, :desc, :desc_es, :weight,
+                    (SELECT id_material FROM materials WHERE name_material = :material))
+            RETURNING id_part
+        """), {'oem': data['oem_part_number'], 'name': data['name'], 'name_es': data.get('name_es'),
+               'group_id': data['group_id'], 'desc': data.get('description'),
+               'desc_es': data.get('description_es'), 'weight': data.get('weight_kg'),
+               'material': data.get('material')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Part created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/parts/<int:part_id>', methods=['PUT'])
 def api_admin_update_part(part_id):
-    """Update an OEM part"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE parts
-            SET oem_part_number = ?, name = ?, name_es = ?, group_id = ?,
-                description = ?, description_es = ?, weight_kg = ?, material = ?, image_url = ?
-            WHERE id = ?
-        """, (
-            data['oem_part_number'],
-            data['name'],
-            data.get('name_es'),
-            data['group_id'],
-            data.get('description'),
-            data.get('description_es'),
-            data.get('weight_kg'),
-            data.get('material'),
-            data.get('image_url'),
-            part_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE parts SET oem_part_number = :oem, name_part = :name, name_es = :name_es,
+                   group_id = :group_id, description = :desc, description_es = :desc_es,
+                   weight_kg = :weight,
+                   id_material = (SELECT id_material FROM materials WHERE name_material = :material)
+            WHERE id_part = :id
+        """), {'oem': data['oem_part_number'], 'name': data['name'], 'name_es': data.get('name_es'),
+               'group_id': data['group_id'], 'desc': data.get('description'),
+               'desc_es': data.get('description_es'), 'weight': data.get('weight_kg'),
+               'material': data.get('material'), 'id': part_id})
+        session.commit()
         return jsonify({'message': 'Part updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/parts/<int:part_id>', methods=['DELETE'])
 def api_admin_delete_part(part_id):
-    """Delete an OEM part"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM parts WHERE id = ?", (part_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM parts WHERE id_part = :id"), {'id': part_id})
+        session.commit()
         return jsonify({'message': 'Part deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Manufacturers CRUD ----
 
 @app.route('/api/admin/manufacturers', methods=['POST'])
 def api_admin_create_manufacturer():
-    """Create a new manufacturer"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO manufacturers (name, type, quality_tier, country, website)
-            VALUES (?, ?, ?, ?, ?)
-        """, (
-            data['name'],
-            data.get('type', 'aftermarket'),
-            data.get('quality_tier', 'standard'),
-            data.get('country'),
-            data.get('website')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO manufacturers (name_manufacture, id_type_manu, id_quality_tier, id_country, website)
+            VALUES (:name,
+                    (SELECT id_type_manu FROM manufacture_type WHERE name_type_manu = :type),
+                    (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt),
+                    (SELECT id_country FROM countries WHERE name_country = :country),
+                    :website)
+            RETURNING id_manufacture
+        """), {'name': data['name'], 'type': data.get('type', 'aftermarket'),
+               'qt': data.get('quality_tier', 'standard'), 'country': data.get('country'),
+               'website': data.get('website')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Manufacturer created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/manufacturers/<int:manufacturer_id>', methods=['PUT'])
 def api_admin_update_manufacturer(manufacturer_id):
-    """Update a manufacturer"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE manufacturers
-            SET name = ?, type = ?, quality_tier = ?, country = ?, website = ?
-            WHERE id = ?
-        """, (
-            data['name'],
-            data.get('type'),
-            data.get('quality_tier'),
-            data.get('country'),
-            data.get('website'),
-            manufacturer_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE manufacturers SET name_manufacture = :name,
+                   id_type_manu = (SELECT id_type_manu FROM manufacture_type WHERE name_type_manu = :type),
+                   id_quality_tier = (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt),
+                   id_country = (SELECT id_country FROM countries WHERE name_country = :country),
+                   website = :website
+            WHERE id_manufacture = :id
+        """), {'name': data['name'], 'type': data.get('type'), 'qt': data.get('quality_tier'),
+               'country': data.get('country'), 'website': data.get('website'), 'id': manufacturer_id})
+        session.commit()
         return jsonify({'message': 'Manufacturer updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/manufacturers/<int:manufacturer_id>', methods=['DELETE'])
 def api_admin_delete_manufacturer(manufacturer_id):
-    """Delete a manufacturer"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM manufacturers WHERE id = ?", (manufacturer_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM manufacturers WHERE id_manufacture = :id"), {'id': manufacturer_id})
+        session.commit()
         return jsonify({'message': 'Manufacturer deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Aftermarket Parts CRUD ----
 
 @app.route('/api/admin/aftermarket', methods=['POST'])
 def api_admin_create_aftermarket():
-    """Create a new aftermarket part"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number, name, name_es, quality_tier, price_usd, warranty_months)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        """, (
-            data['oem_part_id'],
-            data['manufacturer_id'],
-            data['part_number'],
-            data.get('name'),
-            data.get('name_es'),
-            data.get('quality_tier', 'standard'),
-            data.get('price_usd'),
-            data.get('warranty_months')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number,
+                   name_aftermarket_parts, name_es, id_quality_tier, price_usd, warranty_months)
+            VALUES (:oem_part_id, :manufacturer_id, :part_number, :name, :name_es,
+                    (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt),
+                    :price_usd, :warranty_months)
+            RETURNING id_aftermarket_parts
+        """), {'oem_part_id': data['oem_part_id'], 'manufacturer_id': data['manufacturer_id'],
+               'part_number': data['part_number'], 'name': data.get('name'), 'name_es': data.get('name_es'),
+               'qt': data.get('quality_tier', 'standard'), 'price_usd': data.get('price_usd'),
+               'warranty_months': data.get('warranty_months')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Aftermarket part created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/aftermarket/<int:aftermarket_id>', methods=['PUT'])
 def api_admin_update_aftermarket(aftermarket_id):
-    """Update an aftermarket part"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE aftermarket_parts
-            SET oem_part_id = ?, manufacturer_id = ?, part_number = ?, name = ?, name_es = ?,
-                quality_tier = ?, price_usd = ?, warranty_months = ?
-            WHERE id = ?
-        """, (
-            data['oem_part_id'],
-            data['manufacturer_id'],
-            data['part_number'],
-            data.get('name'),
-            data.get('name_es'),
-            data.get('quality_tier'),
-            data.get('price_usd'),
-            data.get('warranty_months'),
-            aftermarket_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE aftermarket_parts SET oem_part_id = :oem_part_id, manufacturer_id = :manufacturer_id,
+                   part_number = :part_number, name_aftermarket_parts = :name, name_es = :name_es,
+                   id_quality_tier = (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt),
+                   price_usd = :price_usd, warranty_months = :warranty_months
+            WHERE id_aftermarket_parts = :id
+        """), {'oem_part_id': data['oem_part_id'], 'manufacturer_id': data['manufacturer_id'],
+               'part_number': data['part_number'], 'name': data.get('name'), 'name_es': data.get('name_es'),
+               'qt': data.get('quality_tier'), 'price_usd': data.get('price_usd'),
+               'warranty_months': data.get('warranty_months'), 'id': aftermarket_id})
+        session.commit()
         return jsonify({'message': 'Aftermarket part updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/aftermarket/<int:aftermarket_id>', methods=['DELETE'])
 def api_admin_delete_aftermarket(aftermarket_id):
-    """Delete an aftermarket part"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM aftermarket_parts WHERE id = ?", (aftermarket_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM aftermarket_parts WHERE id_aftermarket_parts = :id"), {'id': aftermarket_id})
+        session.commit()
         return jsonify({'message': 'Aftermarket part deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Cross-References CRUD ----
 
 @app.route('/api/admin/crossref')
 def api_admin_list_crossref():
-    """List cross-references with pagination"""
+    session = Session()
     try:
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 100)
+        per_page = min(request.args.get('per_page', 50, type=int), 100)
         offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("SELECT COUNT(*) FROM part_cross_references")
-        total_count = cursor.fetchone()[0]
-
-        cursor.execute("""
-            SELECT pcr.id, pcr.part_id, pcr.cross_reference_number, pcr.reference_type, pcr.source, pcr.notes,
-                   p.oem_part_number, p.name AS part_name
+        total_count = session.execute(text("SELECT COUNT(*) FROM part_cross_references")).scalar()
+        rows = session.execute(text("""
+            SELECT pcr.id_part_cross_ref AS id, pcr.part_id, pcr.cross_reference_number,
+                   rt.name_ref_type AS reference_type, pcr.source_ref AS source, pcr.notes,
+                   p.oem_part_number, p.name_part AS part_name
             FROM part_cross_references pcr
-            JOIN parts p ON pcr.part_id = p.id
-            ORDER BY pcr.id DESC
-            LIMIT ? OFFSET ?
-        """, (per_page, offset))
-
-        refs = []
-        for row in cursor.fetchall():
-            refs.append({
-                'id': row['id'],
-                'part_id': row['part_id'],
-                'cross_reference_number': row['cross_reference_number'],
-                'reference_type': row['reference_type'],
-                'source': row['source'],
-                'notes': row['notes'],
-                'oem_part_number': row['oem_part_number'],
-                'part_name': row['part_name']
-            })
-
-        conn.close()
-
+            JOIN parts p ON pcr.part_id = p.id_part
+            LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type
+            ORDER BY pcr.id_part_cross_ref DESC LIMIT :limit OFFSET :offset
+        """), {'limit': per_page, 'offset': offset}).mappings().all()
+        refs = [{'id': r['id'], 'part_id': r['part_id'], 'cross_reference_number': r['cross_reference_number'],
+                 'reference_type': r['reference_type'], 'source': r['source'], 'notes': r['notes'],
+                 'oem_part_number': r['oem_part_number'], 'part_name': r['part_name']} for r in rows]
         total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': refs,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        return jsonify({'data': refs, 'pagination': {'page': page, 'per_page': per_page,
+                        'total': total_count, 'total_pages': total_pages}})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/crossref', methods=['POST'])
 def api_admin_create_crossref():
-    """Create a new cross-reference"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO part_cross_references (part_id, cross_reference_number, reference_type, source, notes)
-            VALUES (?, ?, ?, ?, ?)
-        """, (
-            data['part_id'],
-            data['cross_reference_number'],
-            data['reference_type'],
-            data.get('source'),
-            data.get('notes')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO part_cross_references (part_id, cross_reference_number, id_ref_type, source_ref, notes)
+            VALUES (:part_id, :cross_ref,
+                    (SELECT id_ref_type FROM reference_type WHERE name_ref_type = :ref_type),
+                    :source, :notes)
+            RETURNING id_part_cross_ref
+        """), {'part_id': data['part_id'], 'cross_ref': data['cross_reference_number'],
+               'ref_type': data['reference_type'], 'source': data.get('source'), 'notes': data.get('notes')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Cross-reference created'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/crossref/<int:crossref_id>', methods=['PUT'])
 def api_admin_update_crossref(crossref_id):
-    """Update a cross-reference"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            UPDATE part_cross_references
-            SET part_id = ?, cross_reference_number = ?, reference_type = ?, source = ?, notes = ?
-            WHERE id = ?
-        """, (
-            data['part_id'],
-            data['cross_reference_number'],
-            data['reference_type'],
-            data.get('source'),
-            data.get('notes'),
-            crossref_id
-        ))
-
-        conn.commit()
-        conn.close()
-
+        session.execute(text("""
+            UPDATE part_cross_references SET part_id = :part_id, cross_reference_number = :cross_ref,
+                   id_ref_type = (SELECT id_ref_type FROM reference_type WHERE name_ref_type = :ref_type),
+                   source_ref = :source, notes = :notes
+            WHERE id_part_cross_ref = :id
+        """), {'part_id': data['part_id'], 'cross_ref': data['cross_reference_number'],
+               'ref_type': data['reference_type'], 'source': data.get('source'),
+               'notes': data.get('notes'), 'id': crossref_id})
+        session.commit()
         return jsonify({'message': 'Cross-reference updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/crossref/<int:crossref_id>', methods=['DELETE'])
 def api_admin_delete_crossref(crossref_id):
-    """Delete a cross-reference"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM part_cross_references WHERE id = ?", (crossref_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM part_cross_references WHERE id_part_cross_ref = :id"), {'id': crossref_id})
+        session.commit()
         return jsonify({'message': 'Cross-reference deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ---- Fitment CRUD ----
 
 @app.route('/api/admin/fitment')
 def api_admin_list_fitment():
-    """List fitments with pagination and filters"""
+    session = Session()
     try:
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 50, type=int)
-        per_page = min(per_page, 500)  # Allow more for bulk editor
+        per_page = min(request.args.get('per_page', 50, type=int), 500)
         offset = (page - 1) * per_page
         brand = request.args.get('brand')
         model = request.args.get('model')
         mye_id = request.args.get('mye_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Build WHERE clause
-        where_clause = " WHERE 1=1"
-        params = []
-
+        where = " WHERE 1=1"
+        params = {'limit': per_page, 'offset': offset}
         if mye_id:
-            where_clause += " AND vp.model_year_engine_id = ?"
-            params.append(mye_id)
-
+            where += " AND vp.model_year_engine_id = :mye_id"
+            params['mye_id'] = mye_id
         if brand:
-            where_clause += " AND UPPER(b.name) = UPPER(?)"
-            params.append(brand)
-
+            where += " AND b.name_brand ILIKE :brand"
+            params['brand'] = brand
         if model:
-            where_clause += " AND UPPER(m.name) = UPPER(?)"
-            params.append(model)
-
-        # Count query
-        count_query = """
-            SELECT COUNT(*)
+            where += " AND m.name_model ILIKE :model"
+            params['model'] = model
+        base = """
             FROM vehicle_parts vp
-            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-        """ + where_clause
-        cursor.execute(count_query, params)
-        total_count = cursor.fetchone()[0]
-
-        # Data query
-        data_query = """
-            SELECT vp.id, vp.model_year_engine_id, vp.part_id, vp.quantity_required, vp.position, vp.fitment_notes,
-                   b.name AS brand, m.name AS model, y.year, e.name AS engine,
-                   p.oem_part_number, p.name AS part_name
+            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id_mye
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+        """
+        total_count = session.execute(text("SELECT COUNT(*) " + base + where), params).scalar()
+        rows = session.execute(text("""
+            SELECT vp.id_vehicle_part AS id, vp.model_year_engine_id, vp.part_id,
+                   vp.quantity_required, pp.name_position_part AS position, vp.fitment_notes,
+                   b.name_brand AS brand, m.name_model AS model, y.year_car AS year,
+                   e.name_engine AS engine, p.oem_part_number, p.name_part AS part_name
             FROM vehicle_parts vp
-            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id
-            JOIN models m ON mye.model_id = m.id
-            JOIN brands b ON m.brand_id = b.id
-            JOIN years y ON mye.year_id = y.id
-            JOIN engines e ON mye.engine_id = e.id
-            JOIN parts p ON vp.part_id = p.id
-        """ + where_clause + " ORDER BY vp.id DESC LIMIT ? OFFSET ?"
-
-        cursor.execute(data_query, params + [per_page, offset])
-
-        fitments = []
-        for row in cursor.fetchall():
-            fitments.append({
-                'id': row['id'],
-                'model_year_engine_id': row['model_year_engine_id'],
-                'part_id': row['part_id'],
-                'quantity_required': row['quantity_required'],
-                'position': row['position'],
-                'fitment_notes': row['fitment_notes'],
-                'brand': row['brand'],
-                'model': row['model'],
-                'year': row['year'],
-                'engine': row['engine'],
-                'oem_part_number': row['oem_part_number'],
-                'part_name': row['part_name']
-            })
-
-        conn.close()
-
+            JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id_mye
+            JOIN models m ON mye.model_id = m.id_model
+            JOIN brands b ON m.brand_id = b.id_brand
+            JOIN years y ON mye.year_id = y.id_year
+            JOIN engines e ON mye.engine_id = e.id_engine
+            JOIN parts p ON vp.part_id = p.id_part
+            LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+        """ + where + " ORDER BY vp.id_vehicle_part DESC LIMIT :limit OFFSET :offset"), params).mappings().all()
+        fitments = [dict(r) for r in rows]
         total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': fitments,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        return jsonify({'data': fitments, 'pagination': {'page': page, 'per_page': per_page,
+                        'total': total_count, 'total_pages': total_pages}})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/fitment', methods=['POST'])
 def api_admin_create_fitment():
-    """Create a new fitment record"""
+    session = Session()
     try:
         data = request.get_json()
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, position, fitment_notes)
-            VALUES (?, ?, ?, ?, ?)
-        """, (
-            data['model_year_engine_id'],
-            data['part_id'],
-            data.get('quantity_required', 1),
-            data.get('position'),
-            data.get('fitment_notes')
-        ))
-
-        conn.commit()
-        new_id = cursor.lastrowid
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required,
+                   id_position_part, fitment_notes)
+            VALUES (:mye_id, :part_id, :qty,
+                    (SELECT id_position_part FROM position_part WHERE name_position_part = :position),
+                    :notes)
+            RETURNING id_vehicle_part
+        """), {'mye_id': data['model_year_engine_id'], 'part_id': data['part_id'],
+               'qty': data.get('quantity_required', 1), 'position': data.get('position'),
+               'notes': data.get('fitment_notes')})
+        new_id = result.scalar()
+        session.commit()
         return jsonify({'id': new_id, 'message': 'Fitment created'})
-    except sqlite3.IntegrityError:
+    except IntegrityError:
+        session.rollback()
         return jsonify({'error': 'Este fitment ya existe'}), 400
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/fitment/<int:fitment_id>', methods=['DELETE'])
 def api_admin_delete_fitment(fitment_id):
-    """Delete a fitment record"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("DELETE FROM vehicle_parts WHERE id = ?", (fitment_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM vehicle_parts WHERE id_vehicle_part = :id"), {'id': fitment_id})
+        session.commit()
         return jsonify({'message': 'Fitment deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
-# ---- CSV Import/Export ----
+# ============================================================================
+# CSV Import
+# ============================================================================
 
 @app.route('/api/admin/import/<import_type>', methods=['POST'])
 def api_admin_import_csv(import_type):
-    """Import records from CSV data"""
+    session = Session()
     try:
         data = request.get_json()
         records = data.get('records', [])
-
         if not records:
             return jsonify({'error': 'No records to import'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         imported = 0
         errors = []
-
-        for i, record in enumerate(records):
+        for i, rec in enumerate(records):
             try:
                 if import_type == 'categories':
-                    cursor.execute("""
-                        INSERT INTO part_categories (name, name_es, slug, icon_name, display_order)
-                        VALUES (?, ?, ?, ?, ?)
-                    """, (
-                        record['name'],
-                        record.get('name_es'),
-                        record.get('slug') or record['name'].lower().replace(' ', '-'),
-                        record.get('icon_name'),
-                        record.get('display_order', 0)
-                    ))
-
+                    session.execute(text("INSERT INTO part_categories (name_part_category, name_es, slug, icon_name, display_order) VALUES (:name, :name_es, :slug, :icon_name, :do)"),
+                        {'name': rec['name'], 'name_es': rec.get('name_es'), 'slug': rec.get('slug') or rec['name'].lower().replace(' ', '-'), 'icon_name': rec.get('icon_name'), 'do': rec.get('display_order', 0)})
                 elif import_type == 'groups':
-                    cursor.execute("""
-                        INSERT INTO part_groups (category_id, name, name_es, display_order)
-                        VALUES (?, ?, ?, ?)
-                    """, (
-                        record['category_id'],
-                        record['name'],
-                        record.get('name_es'),
-                        record.get('display_order', 0)
-                    ))
-
+                    session.execute(text("INSERT INTO part_groups (category_id, name_part_group, name_es, display_order) VALUES (:cid, :name, :name_es, :do)"),
+                        {'cid': rec['category_id'], 'name': rec['name'], 'name_es': rec.get('name_es'), 'do': rec.get('display_order', 0)})
                 elif import_type == 'parts':
-                    cursor.execute("""
-                        INSERT INTO parts (oem_part_number, name, name_es, group_id, description, description_es, weight_kg, material)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                    """, (
-                        record['oem_part_number'],
-                        record['name'],
-                        record.get('name_es'),
-                        record['group_id'],
-                        record.get('description'),
-                        record.get('description_es'),
-                        record.get('weight_kg'),
-                        record.get('material')
-                    ))
-
+                    session.execute(text("""INSERT INTO parts (oem_part_number, name_part, name_es, group_id, description, description_es, weight_kg, id_material)
+                        VALUES (:oem, :name, :name_es, :gid, :desc, :desc_es, :weight, (SELECT id_material FROM materials WHERE name_material = :material))"""),
+                        {'oem': rec['oem_part_number'], 'name': rec['name'], 'name_es': rec.get('name_es'), 'gid': rec['group_id'], 'desc': rec.get('description'), 'desc_es': rec.get('description_es'), 'weight': rec.get('weight_kg'), 'material': rec.get('material')})
                 elif import_type == 'manufacturers':
-                    cursor.execute("""
-                        INSERT INTO manufacturers (name, type, quality_tier, country, website)
-                        VALUES (?, ?, ?, ?, ?)
-                    """, (
-                        record['name'],
-                        record.get('type', 'aftermarket'),
-                        record.get('quality_tier', 'standard'),
-                        record.get('country'),
-                        record.get('website')
-                    ))
-
+                    session.execute(text("""INSERT INTO manufacturers (name_manufacture, id_type_manu, id_quality_tier, id_country, website)
+                        VALUES (:name, (SELECT id_type_manu FROM manufacture_type WHERE name_type_manu = :type),
+                        (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt),
+                        (SELECT id_country FROM countries WHERE name_country = :country), :website)"""),
+                        {'name': rec['name'], 'type': rec.get('type', 'aftermarket'), 'qt': rec.get('quality_tier', 'standard'), 'country': rec.get('country'), 'website': rec.get('website')})
                 elif import_type == 'aftermarket':
-                    cursor.execute("""
-                        INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number, name, name_es, quality_tier, price_usd, warranty_months)
-                        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-                    """, (
-                        record['oem_part_id'],
-                        record['manufacturer_id'],
-                        record['part_number'],
-                        record.get('name'),
-                        record.get('name_es'),
-                        record.get('quality_tier', 'standard'),
-                        record.get('price_usd'),
-                        record.get('warranty_months')
-                    ))
-
+                    session.execute(text("""INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number, name_aftermarket_parts, name_es, id_quality_tier, price_usd, warranty_months)
+                        VALUES (:oem_part_id, :mid, :pn, :name, :name_es,
+                        (SELECT id_quality_tier FROM quality_tier WHERE name_quality = :qt), :price, :warranty)"""),
+                        {'oem_part_id': rec['oem_part_id'], 'mid': rec['manufacturer_id'], 'pn': rec['part_number'], 'name': rec.get('name'), 'name_es': rec.get('name_es'), 'qt': rec.get('quality_tier', 'standard'), 'price': rec.get('price_usd'), 'warranty': rec.get('warranty_months')})
                 elif import_type == 'crossref':
-                    cursor.execute("""
-                        INSERT INTO part_cross_references (part_id, cross_reference_number, reference_type, source, notes)
-                        VALUES (?, ?, ?, ?, ?)
-                    """, (
-                        record['part_id'],
-                        record['cross_reference_number'],
-                        record['reference_type'],
-                        record.get('source'),
-                        record.get('notes')
-                    ))
-
+                    session.execute(text("""INSERT INTO part_cross_references (part_id, cross_reference_number, id_ref_type, source_ref, notes)
+                        VALUES (:pid, :cross_ref, (SELECT id_ref_type FROM reference_type WHERE name_ref_type = :ref_type), :source, :notes)"""),
+                        {'pid': rec['part_id'], 'cross_ref': rec['cross_reference_number'], 'ref_type': rec.get('reference_type'), 'source': rec.get('source'), 'notes': rec.get('notes')})
                 elif import_type == 'fitment':
-                    cursor.execute("""
-                        INSERT OR IGNORE INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, position, fitment_notes)
-                        VALUES (?, ?, ?, ?, ?)
-                    """, (
-                        record['model_year_engine_id'],
-                        record['part_id'],
-                        record.get('quantity_required', 1),
-                        record.get('position'),
-                        record.get('fitment_notes')
-                    ))
-
+                    session.execute(text("""INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, id_position_part, fitment_notes)
+                        VALUES (:mye_id, :pid, :qty, (SELECT id_position_part FROM position_part WHERE name_position_part = :position), :notes)
+                        ON CONFLICT (model_year_engine_id, part_id, id_position_part) DO NOTHING"""),
+                        {'mye_id': rec['model_year_engine_id'], 'pid': rec['part_id'], 'qty': rec.get('quantity_required', 1), 'position': rec.get('position'), 'notes': rec.get('fitment_notes')})
+                else:
+                    return jsonify({'error': f'Unknown import type: {import_type}'}), 400
                 imported += 1
-
             except Exception as e:
                 errors.append(f"Row {i + 1}: {str(e)}")
-
-        conn.commit()
-        conn.close()
-
+        session.commit()
         result = {'imported': imported}
         if errors:
-            result['errors'] = errors[:10]  # Limit errors shown
-
+            result['errors'] = errors[:10]
         return jsonify(result)
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
+# ============================================================================
+# CSV Export
+# ============================================================================
+
 @app.route('/api/admin/export/<export_type>')
 def api_admin_export_csv(export_type):
-    """Export data as JSON with pagination (to be converted to CSV on frontend)"""
+    session = Session()
     try:
         page = request.args.get('page', 1, type=int)
-        per_page = request.args.get('per_page', 1000, type=int)
-        per_page = min(per_page, 10000)
+        per_page = min(request.args.get('per_page', 1000, type=int), 10000)
         offset = (page - 1) * per_page
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
         export_queries = {
-            'categories': ("SELECT id, name, name_es, slug, icon_name, display_order FROM part_categories ORDER BY display_order, name", "part_categories"),
-            'groups': ("SELECT id, category_id, name, name_es, display_order FROM part_groups ORDER BY category_id, display_order, name", "part_groups"),
-            'parts': ("SELECT id, oem_part_number, name, name_es, group_id, description, description_es, weight_kg, material FROM parts ORDER BY id", "parts"),
-            'manufacturers': ("SELECT id, name, type, quality_tier, country, website FROM manufacturers ORDER BY name", "manufacturers"),
-            'aftermarket': ("SELECT id, oem_part_id, manufacturer_id, part_number, name, name_es, quality_tier, price_usd, warranty_months FROM aftermarket_parts ORDER BY id", "aftermarket_parts"),
-            'crossref': ("SELECT id, part_id, cross_reference_number, reference_type, source, notes FROM part_cross_references ORDER BY id", "part_cross_references"),
-            'fitment': ("SELECT id, model_year_engine_id, part_id, quantity_required, position, fitment_notes FROM vehicle_parts ORDER BY id", "vehicle_parts"),
+            'categories': ("SELECT id_part_category AS id, name_part_category AS name, name_es, slug, icon_name, display_order FROM part_categories ORDER BY display_order, name_part_category", "part_categories"),
+            'groups': ("SELECT id_part_group AS id, category_id, name_part_group AS name, name_es, display_order FROM part_groups ORDER BY category_id, display_order, name_part_group", "part_groups"),
+            'parts': ("SELECT p.id_part AS id, p.oem_part_number, p.name_part AS name, p.name_es, p.group_id, p.description, p.description_es, p.weight_kg, mat.name_material AS material FROM parts p LEFT JOIN materials mat ON p.id_material = mat.id_material ORDER BY p.id_part", "parts"),
+            'manufacturers': ("SELECT mfr.id_manufacture AS id, mfr.name_manufacture AS name, mt.name_type_manu AS type, qt.name_quality AS quality_tier, co.name_country AS country, mfr.website FROM manufacturers mfr LEFT JOIN manufacture_type mt ON mfr.id_type_manu = mt.id_type_manu LEFT JOIN quality_tier qt ON mfr.id_quality_tier = qt.id_quality_tier LEFT JOIN countries co ON mfr.id_country = co.id_country ORDER BY mfr.name_manufacture", "manufacturers"),
+            'aftermarket': ("SELECT ap.id_aftermarket_parts AS id, ap.oem_part_id, ap.manufacturer_id, ap.part_number, ap.name_aftermarket_parts AS name, ap.name_es, qt.name_quality AS quality_tier, ap.price_usd, ap.warranty_months FROM aftermarket_parts ap LEFT JOIN quality_tier qt ON ap.id_quality_tier = qt.id_quality_tier ORDER BY ap.id_aftermarket_parts", "aftermarket_parts"),
+            'crossref': ("SELECT pcr.id_part_cross_ref AS id, pcr.part_id, pcr.cross_reference_number, rt.name_ref_type AS reference_type, pcr.source_ref AS source, pcr.notes FROM part_cross_references pcr LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type ORDER BY pcr.id_part_cross_ref", "part_cross_references"),
+            'fitment': ("SELECT vp.id_vehicle_part AS id, vp.model_year_engine_id, vp.part_id, vp.quantity_required, pp.name_position_part AS position, vp.fitment_notes FROM vehicle_parts vp LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part ORDER BY vp.id_vehicle_part", "vehicle_parts"),
         }
-
         if export_type not in export_queries:
-            conn.close()
             return jsonify({'error': f'Unknown export type: {export_type}'}), 400
-
         base_query, table_name = export_queries[export_type]
-
-        # Get total count
-        cursor.execute(f"SELECT COUNT(*) as total FROM {table_name}")
-        total_count = cursor.fetchone()['total']
-
-        # Get paginated data
-        cursor.execute(base_query + " LIMIT ? OFFSET ?", (per_page, offset))
-        data = [dict(row) for row in cursor.fetchall()]
-
-        conn.close()
-
+        total_count = session.execute(text(f"SELECT COUNT(*) FROM {table_name}")).scalar()
+        rows = session.execute(text(base_query + " LIMIT :limit OFFSET :offset"), {'limit': per_page, 'offset': offset}).mappings().all()
+        data_list = [dict(r) for r in rows]
         total_pages = (total_count + per_page - 1) // per_page
-        return jsonify({
-            'data': data,
-            'pagination': {
-                'page': page,
-                'per_page': per_page,
-                'total': total_count,
-                'total_pages': total_pages
-            }
-        })
+        return jsonify({'data': data_list, 'pagination': {'page': page, 'per_page': per_page,
+                        'total': total_count, 'total_pages': total_pages}})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 # ============================================================================
-# Image Upload Endpoint
+# Image Upload
 # ============================================================================
 
-import base64
-import uuid
-
 @app.route('/api/admin/upload-image', methods=['POST'])
 def api_admin_upload_image():
-    """Upload a base64 encoded image and save it to the server"""
     try:
         data = request.get_json()
         image_data = data.get('image')
-
         if not image_data:
             return jsonify({'error': 'No image data provided'}), 400
-
-        # Parse base64 data
         if ',' in image_data:
-            # Format: data:image/png;base64,xxxxx
             header, encoded = image_data.split(',', 1)
-            # Extract extension from header
-            if 'png' in header:
-                ext = 'png'
-            elif 'jpeg' in header or 'jpg' in header:
+            ext = 'png'
+            if 'jpeg' in header or 'jpg' in header:
                 ext = 'jpg'
             elif 'gif' in header:
                 ext = 'gif'
             elif 'webp' in header:
                 ext = 'webp'
-            else:
-                ext = 'png'
         else:
             encoded = image_data
             ext = 'png'
-
-        # Decode the image
         image_bytes = base64.b64decode(encoded)
-
-        # Generate unique filename
         filename = f"{uuid.uuid4().hex}.{ext}"
         filepath = os.path.join('static', 'parts_images', filename)
-
-        # Ensure directory exists
         os.makedirs(os.path.join('.', 'static', 'parts_images'), exist_ok=True)
-
-        # Save the file
         with open(filepath, 'wb') as f:
             f.write(image_bytes)
-
-        # Return the URL
-        url = f"/static/parts_images/{filename}"
-        return jsonify({'url': url, 'filename': filename})
-
+        return jsonify({'url': f"/static/parts_images/{filename}", 'filename': filename})
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
 
 # ============================================================================
-# FASE 6: Diagrams Integration - Additional Endpoints
+# Diagrams by Category
 # ============================================================================
 
 @app.route('/api/vehicles/<int:mye_id>/diagrams/by-category')
 def api_vehicle_diagrams_by_category(mye_id):
-    """Get diagrams for a vehicle grouped by category, optionally filtered by category_id"""
+    session = Session()
     try:
         category_id = request.args.get('category_id', type=int)
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        query = """
-            SELECT DISTINCT
-                d.id,
-                d.name,
-                d.name_es,
-                d.group_id,
-                d.image_path,
-                d.thumbnail_path,
-                pg.name AS group_name,
-                pg.name_es AS group_name_es,
-                pc.id AS category_id,
-                pc.name AS category_name,
-                pc.name_es AS category_name_es,
-                vd.notes
-            FROM vehicle_diagrams vd
-            JOIN diagrams d ON vd.diagram_id = d.id
-            JOIN part_groups pg ON d.group_id = pg.id
-            JOIN part_categories pc ON pg.category_id = pc.id
-            WHERE vd.model_year_engine_id = ?
-        """
-        params = [mye_id]
-
+        params = {'mye_id': mye_id}
+        cat_filter = ""
         if category_id:
-            query += " AND pc.id = ?"
-            params.append(category_id)
-
-        query += " ORDER BY pc.display_order, pg.display_order, d.display_order, d.name"
-
-        cursor.execute(query, params)
-
-        # Group by category
+            cat_filter = " AND pc.id_part_category = :cid"
+            params['cid'] = category_id
+        rows = session.execute(text(f"""
+            SELECT DISTINCT d.id_diagram AS id, d.name_diagram AS name, d.name_es,
+                   d.group_id, d.image_path, d.thumbnail_path,
+                   pg.name_part_group AS group_name, pg.name_es AS group_name_es,
+                   pc.id_part_category AS category_id, pc.name_part_category AS category_name,
+                   pc.name_es AS category_name_es, vd.notes
+            FROM vehicle_diagrams vd
+            JOIN diagrams d ON vd.diagram_id = d.id_diagram
+            JOIN part_groups pg ON d.group_id = pg.id_part_group
+            JOIN part_categories pc ON pg.category_id = pc.id_part_category
+            WHERE vd.model_year_engine_id = :mye_id {cat_filter}
+            ORDER BY pc.display_order, pg.display_order, d.display_order, d.name_diagram
+        """), params).mappings().all()
         categories = {}
-        for row in cursor.fetchall():
-            cat_id = row['category_id']
-            if cat_id not in categories:
-                categories[cat_id] = {
-                    'category_id': cat_id,
-                    'category_name': row['category_name'],
-                    'category_name_es': row['category_name_es'],
-                    'diagrams': []
-                }
-            image_path = row['image_path'] or ''
-            image_url = '/' + image_path if image_path and not image_path.startswith('/') else image_path
-            categories[cat_id]['diagrams'].append({
-                'id': row['id'],
-                'name': row['name'],
-                'name_es': row['name_es'],
-                'group_id': row['group_id'],
-                'group_name': row['group_name'],
-                'group_name_es': row['group_name_es'],
-                'image_url': image_url,
-                'thumbnail_path': row['thumbnail_path'],
-                'notes': row['notes']
-            })
-
-        conn.close()
+        for r in rows:
+            cid = r['category_id']
+            if cid not in categories:
+                categories[cid] = {'category_id': cid, 'category_name': r['category_name'],
+                                   'category_name_es': r['category_name_es'], 'diagrams': []}
+            ip = r['image_path'] or ''
+            iu = '/' + ip if ip and not ip.startswith('/') else ip
+            categories[cid]['diagrams'].append({'id': r['id'], 'name': r['name'], 'name_es': r['name_es'],
+                'group_id': r['group_id'], 'group_name': r['group_name'],
+                'group_name_es': r['group_name_es'], 'image_url': iu,
+                'thumbnail_path': r['thumbnail_path'], 'notes': r['notes']})
         return jsonify(list(categories.values()))
     except Exception as e:
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
+# ============================================================================
+# Hotspot CRUD
+# ============================================================================
+
 @app.route('/api/admin/hotspots', methods=['POST'])
 def api_admin_create_hotspot():
-    """Create a new hotspot on a diagram"""
+    session = Session()
     try:
         data = request.get_json()
         if not data:
             return jsonify({'error': 'No data provided'}), 400
-
         diagram_id = data.get('diagram_id')
-        part_id = data.get('part_id')
-        callout_number = data.get('callout_number')
-        label = data.get('label', '')
-        shape = data.get('shape', 'circle')
         coords = data.get('coords', '')
-        color = data.get('color', '#e74c3c')
-
         if not diagram_id or not coords:
             return jsonify({'error': 'diagram_id and coords are required'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("""
-            INSERT INTO diagram_hotspots (diagram_id, part_id, callout_number, label, shape, coords, color)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-        """, (diagram_id, part_id, callout_number, label, shape, coords, color))
-
-        hotspot_id = cursor.lastrowid
-        conn.commit()
-        conn.close()
-
+        result = session.execute(text("""
+            INSERT INTO diagram_hotspots (diagram_id, part_id, callout_number, id_shape, coords)
+            VALUES (:did, :pid, :callout,
+                    (SELECT id_shape FROM shapes WHERE name_shape = :shape), :coords)
+            RETURNING id_dgr_hotspot
+        """), {'did': diagram_id, 'pid': data.get('part_id'),
+               'callout': data.get('callout_number'), 'shape': data.get('shape', 'circle'),
+               'coords': coords})
+        hotspot_id = result.scalar()
+        session.commit()
         return jsonify({'id': hotspot_id, 'message': 'Hotspot created'}), 201
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/hotspots/<int:hotspot_id>', methods=['PUT'])
 def api_admin_update_hotspot(hotspot_id):
-    """Update an existing hotspot"""
+    session = Session()
     try:
         data = request.get_json()
         if not data:
             return jsonify({'error': 'No data provided'}), 400
-
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Check it exists
-        cursor.execute("SELECT id FROM diagram_hotspots WHERE id = ?", (hotspot_id,))
-        if not cursor.fetchone():
-            conn.close()
+        exists = session.execute(text("SELECT id_dgr_hotspot FROM diagram_hotspots WHERE id_dgr_hotspot = :id"), {'id': hotspot_id}).mappings().first()
+        if not exists:
             return jsonify({'error': 'Hotspot not found'}), 404
-
         fields = []
-        params = []
-        for field in ['part_id', 'callout_number', 'label', 'shape', 'coords', 'color']:
-            if field in data:
-                fields.append(f"{field} = ?")
-                params.append(data[field])
-
+        params = {'id': hotspot_id}
+        if 'part_id' in data:
+            fields.append("part_id = :part_id")
+            params['part_id'] = data['part_id']
+        if 'callout_number' in data:
+            fields.append("callout_number = :callout_number")
+            params['callout_number'] = data['callout_number']
+        if 'shape' in data:
+            fields.append("id_shape = (SELECT id_shape FROM shapes WHERE name_shape = :shape)")
+            params['shape'] = data['shape']
+        if 'coords' in data:
+            fields.append("coords = :coords")
+            params['coords'] = data['coords']
         if not fields:
-            conn.close()
             return jsonify({'error': 'No fields to update'}), 400
-
-        params.append(hotspot_id)
-        cursor.execute(f"UPDATE diagram_hotspots SET {', '.join(fields)} WHERE id = ?", params)
-        conn.commit()
-        conn.close()
-
+        session.execute(text(f"UPDATE diagram_hotspots SET {', '.join(fields)} WHERE id_dgr_hotspot = :id"), params)
+        session.commit()
         return jsonify({'message': 'Hotspot updated'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
 @app.route('/api/admin/hotspots/<int:hotspot_id>', methods=['DELETE'])
 def api_admin_delete_hotspot(hotspot_id):
-    """Delete a hotspot"""
+    session = Session()
     try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        cursor.execute("SELECT id FROM diagram_hotspots WHERE id = ?", (hotspot_id,))
-        if not cursor.fetchone():
-            conn.close()
+        exists = session.execute(text("SELECT id_dgr_hotspot FROM diagram_hotspots WHERE id_dgr_hotspot = :id"), {'id': hotspot_id}).mappings().first()
+        if not exists:
             return jsonify({'error': 'Hotspot not found'}), 404
-
-        cursor.execute("DELETE FROM diagram_hotspots WHERE id = ?", (hotspot_id,))
-        conn.commit()
-        conn.close()
-
+        session.execute(text("DELETE FROM diagram_hotspots WHERE id_dgr_hotspot = :id"), {'id': hotspot_id})
+        session.commit()
         return jsonify({'message': 'Hotspot deleted'})
     except Exception as e:
+        session.rollback()
         return jsonify({'error': str(e)}), 500
+    finally:
+        session.close()
 
 
+# ============================================================================
+# Main Block
+# ============================================================================
+
 if __name__ == '__main__':
-    # Check if database exists
-    if not os.path.exists(DATABASE_PATH):
-        print(f"Database not found at {DATABASE_PATH}")
-        print("Please make sure the vehicle database is created first.")
-        exit(1)
-
-    print("Starting Vehicle Dashboard Server...")
+    print("Starting Nexus Autoparts Dashboard Server...")
     print("Visit http://localhost:5000 to access the dashboard locally")
-    print("Visit http://192.168.10.198:5000 to access the dashboard from other computers on the network")
-    app.run(debug=False, host='0.0.0.0', port=5000)
\ No newline at end of file
+    app.run(debug=False, host='0.0.0.0', port=5000)
diff --git a/dashboard/shared.css b/dashboard/shared.css
index 04f1c6f..3868194 100644
--- a/dashboard/shared.css
+++ b/dashboard/shared.css
@@ -1,5 +1,5 @@
 /* ============================================================
-   shared.css  --  Common styles for all AutoParts DB pages
+   shared.css  --  Common styles for all Nexus Autoparts pages
    ============================================================ */
 
 /* --- Reset --- */
diff --git a/docs/API.md b/docs/API.md
index 1505d02..091fcce 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -1,6 +1,6 @@
-# API Reference - Autoparts DB
+# API Reference - Nexus Autoparts
 
-Documentación completa de la API REST del sistema Autoparts DB.
+Documentación completa de la API REST del sistema Nexus Autoparts.
 
 ## Base URL
 
diff --git a/docs/DATABASE.md b/docs/DATABASE.md
index 1ce6ad9..010ef4f 100644
--- a/docs/DATABASE.md
+++ b/docs/DATABASE.md
@@ -1,4 +1,4 @@
-# Documentación de Base de Datos - Autoparts DB
+# Documentación de Base de Datos - Nexus Autoparts
 
 ## Resumen
 
diff --git a/docs/INSTALLATION.md b/docs/INSTALLATION.md
index 2c4a2a6..aa2b603 100644
--- a/docs/INSTALLATION.md
+++ b/docs/INSTALLATION.md
@@ -1,4 +1,4 @@
-# Guía de Instalación - Autoparts DB
+# Guía de Instalación - Nexus Autoparts
 
 ## Requisitos del Sistema
 
@@ -28,10 +28,10 @@ El proyecto es compatible con:
 
 ```bash
 # 1. Clonar el repositorio
-git clone https://git.consultoria-as.com/[usuario]/Autoparts-DB.git
+git clone https://git.consultoria-as.com/[usuario]/Nexus-Autoparts.git
 
 # 2. Entrar al directorio
-cd Autoparts-DB
+cd Nexus-Autoparts
 
 # 3. Instalar dependencias
 pip install -r requirements.txt
@@ -48,8 +48,8 @@ python3 server.py
 ### Paso 1: Clonar el Repositorio
 
 ```bash
-git clone https://git.consultoria-as.com/[usuario]/Autoparts-DB.git
-cd Autoparts-DB
+git clone https://git.consultoria-as.com/[usuario]/Nexus-Autoparts.git
+cd Nexus-Autoparts
 ```
 
 ### Paso 2: Crear Entorno Virtual (Recomendado)
@@ -254,16 +254,16 @@ gunicorn -w 4 -b 0.0.0.0:8080 server:app
 
 ### Usando systemd
 
-Crear archivo `/etc/systemd/system/autoparts-db.service`:
+Crear archivo `/etc/systemd/system/nexus-autoparts.service`:
 
 ```ini
 [Unit]
-Description=Autoparts DB Dashboard
+Description=Nexus Autoparts Dashboard
 After=network.target
 
 [Service]
 User=www-data
-WorkingDirectory=/path/to/Autoparts-DB/dashboard
+WorkingDirectory=/path/to/Nexus-Autoparts/dashboard
 ExecStart=/usr/bin/python3 server.py
 Restart=always
 
@@ -274,8 +274,8 @@ WantedBy=multi-user.target
 Habilitar e iniciar:
 
 ```bash
-sudo systemctl enable autoparts-db
-sudo systemctl start autoparts-db
+sudo systemctl enable nexus-autoparts
+sudo systemctl start nexus-autoparts
 ```
 
 ### Usando Docker (Opcional)
@@ -294,8 +294,8 @@ CMD ["python3", "dashboard/server.py"]
 ```
 
 ```bash
-docker build -t autoparts-db .
-docker run -p 5000:5000 autoparts-db
+docker build -t nexus-autoparts .
+docker run -p 5000:5000 nexus-autoparts
 ```
 
 ---
@@ -319,7 +319,7 @@ pip install --upgrade -r requirements.txt
 deactivate
 
 # Eliminar directorio del proyecto
-rm -rf Autoparts-DB
+rm -rf Nexus-Autoparts
 
 # Eliminar entorno virtual (si está separado)
 rm -rf venv
diff --git a/docs/METABASE_GUIDE.md b/docs/METABASE_GUIDE.md
new file mode 100644
index 0000000..ddeefcc
--- /dev/null
+++ b/docs/METABASE_GUIDE.md
@@ -0,0 +1,599 @@
+# Guía Metabase — Nexus Autoparts
+
+## 1. Conexión a la Base de Datos
+
+### Datos de conexión PostgreSQL
+
+| Campo | Valor |
+|-------|-------|
+| **Host** | `localhost` (o la IP del servidor: `192.168.10.198`) |
+| **Puerto** | `5432` |
+| **Base de datos** | `nexus_autoparts` |
+| **Usuario** | `nexus` |
+| **Contraseña** | `nexus_autoparts_2026` |
+| **SSL** | No requerido (conexión local) |
+
+### Pasos en Metabase
+
+1. Ir a **Admin** → **Databases** → **Add database**
+2. Seleccionar **PostgreSQL**
+3. Llenar los campos con los datos anteriores
+4. Click **Save**
+5. Metabase sincronizará las tablas automáticamente (~30 segundos)
+
+> **Tip:** Si Metabase está en otro servidor, usar la IP `192.168.10.198` en lugar de `localhost`.
+
+---
+
+## 2. Estructura de la Base de Datos
+
+### Diagrama de relaciones simplificado
+
+```
+brands ──→ models ──→ model_year_engine (MYE) ←── years
+                            ↑    ↑                    ↑
+                         engines  │               vehicle_parts ──→ parts
+                                  │                                   ↑
+                            vehicle_diagrams              part_cross_references
+                                  ↓                       aftermarket_parts
+                              diagrams                    diagram_hotspots
+```
+
+### Tablas principales (con datos)
+
+| Tabla | Registros | Descripción |
+|-------|-----------|-------------|
+| `brands` | 102 | Marcas de vehículos |
+| `models` | 4,031 | Modelos por marca |
+| `years` | 80 | Años (1946-2026) |
+| `engines` | 13,430 | Motores con specs |
+| `model_year_engine` | 47,858 | Combinación marca-modelo-año-motor |
+
+### Tablas de piezas (vacías — para llenar)
+
+| Tabla | Descripción |
+|-------|-------------|
+| `parts` | Piezas OEM (número de parte, nombre, grupo) |
+| `vehicle_parts` | Relación pieza ↔ vehículo (fitments) |
+| `aftermarket_parts` | Piezas aftermarket por fabricante |
+| `part_cross_references` | Intercambios y referencias cruzadas |
+| `manufacturers` | 47 fabricantes ya cargados |
+
+### Tablas lookup (catálogos de referencia)
+
+| Tabla | Valores actuales |
+|-------|-----------------|
+| `part_categories` | 12: Body, Brake, Cooling, Drivetrain, Electrical, Engine, Exhaust, Fuel, HVAC, Steering, Suspension, Transmission |
+| `part_groups` | 63 grupos dentro de las categorías |
+| `quality_tier` | economy, standard, oem, premium |
+| `reference_type` | competitor, interchange, oem_alternate, supersession |
+| `position_part` | front, rear |
+| `manufacture_type` | aftermarket, oem |
+| `materials` | (vacía — agregar según se necesite) |
+
+---
+
+## 3. Alta de Piezas OEM
+
+### Orden obligatorio de carga
+
+```
+1. materials        (si aplica)
+2. parts            ← PRIMERO las piezas
+3. vehicle_parts    ← DESPUÉS los fitments
+4. aftermarket_parts
+5. part_cross_references
+```
+
+> **IMPORTANTE:** Respetar este orden. `vehicle_parts` y `aftermarket_parts` requieren que la pieza ya exista en `parts`.
+
+---
+
+### 3.1 Agregar una pieza OEM (`parts`)
+
+En Metabase: click **+ New** → **SQL query** → ejecutar:
+
+```sql
+INSERT INTO parts (oem_part_number, name_part, name_es, group_id, description, description_es, weight_kg, id_material)
+VALUES (
+    '04465-06090',                    -- Número OEM (obligatorio, único por grupo)
+    'Front Brake Pad Set',            -- Nombre en inglés (obligatorio)
+    'Juego de Balatas Delanteras',    -- Nombre en español (opcional)
+    16,                               -- group_id: 16 = Brake Pads (ver tabla abajo)
+    'Ceramic brake pad set for front axle',  -- Descripción EN (opcional)
+    'Juego de balatas cerámicas para eje delantero',  -- Descripción ES (opcional)
+    1.2,                              -- Peso en kg (opcional)
+    NULL                              -- id_material (opcional, ver tabla materials)
+);
+```
+
+### Carga masiva de piezas
+
+```sql
+INSERT INTO parts (oem_part_number, name_part, name_es, group_id, description) VALUES
+    ('04465-06090', 'Front Brake Pad Set', 'Juego Balatas Delanteras', 16, 'Ceramic front pads'),
+    ('04465-33471', 'Front Brake Pad Set', 'Juego Balatas Delanteras', 16, 'Semi-metallic front pads'),
+    ('43512-06150', 'Front Brake Rotor', 'Disco de Freno Delantero', 17, 'Vented front rotor 296mm'),
+    ('19101-28491', 'Radiator', 'Radiador', 31, 'Aluminum core radiator'),
+    ('16400-28531', 'Cooling Fan Assembly', 'Ensamble Ventilador', 35, 'Electric cooling fan')
+ON CONFLICT DO NOTHING;
+```
+
+### Referencia de `group_id` (grupos de piezas)
+
+| group_id | Grupo | Categoría |
+|----------|-------|-----------|
+| **Frenos y Ruedas** | | |
+| 16 | Brake Pads | Brake & Wheel Hub |
+| 17 | Brake Rotors | Brake & Wheel Hub |
+| 20 | Brake Calipers | Brake & Wheel Hub |
+| 27 | Wheel Bearings | Brake & Wheel Hub |
+| 28 | Wheel Hubs | Brake & Wheel Hub |
+| **Motor** | | |
+| 70 | Oil Filters | Engine |
+| 71 | Air Filters | Engine |
+| 72 | Spark Plugs | Engine |
+| 73 | Belts | Engine |
+| 76 | Timing Components | Engine |
+| 91 | Engine Mounts | Engine |
+| **Enfriamiento** | | |
+| 31 | Radiators | Cooling System |
+| 33 | Water Pumps | Cooling System |
+| 34 | Thermostats | Cooling System |
+| 35 | Cooling Fans | Cooling System |
+| **Eléctrico** | | |
+| 55 | Alternators | Electrical & Lighting |
+| 56 | Starters | Electrical & Lighting |
+| 57 | Ignition Coils | Electrical & Lighting |
+| 65 | Sensors | Electrical & Lighting |
+| **Combustible** | | |
+| 110 | Fuel Pumps | Fuel & Air |
+| 111 | Fuel Filters | Fuel & Air |
+| 112 | Fuel Injectors | Fuel & Air |
+| **Escape** | | |
+| 99 | Catalytic Converters | Exhaust |
+| 100 | Mufflers | Exhaust |
+| 108 | Headers | Exhaust |
+| **Dirección** | | |
+| 141 | Power Steering Pumps | Steering |
+| 144 | Steering Racks | Steering |
+| 145 | Steering Gearboxes | Steering |
+| 146 | Tie Rods | Steering |
+| 147 | Tie Rod Ends | Steering |
+| 148 | Inner Tie Rods | Steering |
+| 151 | Pitman Arms | Steering |
+| 152 | Idler Arms | Steering |
+| 153 | Center Links | Steering |
+| 154 | Drag Links | Steering |
+| 155 | Steering Knuckles | Steering |
+| 191 | Steering Dampers | Steering |
+| **Suspensión** | | |
+| 156 | Shocks | Suspension |
+| 157 | Struts | Suspension |
+| 158 | Strut Mounts | Suspension |
+| 159 | Coil Springs | Suspension |
+| 160 | Leaf Springs | Suspension |
+| 161 | Control Arms | Suspension |
+| 164 | Ball Joints | Suspension |
+| 165 | Bushings | Suspension |
+| 167 | Sway Bar Links | Suspension |
+| 168 | Sway Bar Bushings | Suspension |
+| 169 | Torsion Bars | Suspension |
+| 170 | Trailing Arms | Suspension |
+| **Transmisión** | | |
+| 175 | Transmission Filters | Transmission |
+| 185 | Transmission Mounts | Transmission |
+| **A/C y Calefacción** | | |
+| 127 | AC Compressors | Heat & Air Conditioning |
+| 135 | Blower Motors | Heat & Air Conditioning |
+| 138 | Cabin Air Filters | Heat & Air Conditioning |
+| **Tren Motriz** | | |
+| 44 | CV Axles | Drivetrain |
+| 45 | CV Joints | Drivetrain |
+| 50 | Axle Shafts | Drivetrain |
+| **Carrocería** | | |
+| 15 | Moldings & Trim | Body & Lamp Assembly |
+
+---
+
+## 4. Alta de Fitments (Pieza ↔ Vehículo)
+
+Un fitment vincula una pieza con un vehículo específico (combinación modelo-año-motor).
+
+### 4.1 Encontrar el `id_mye` del vehículo
+
+```sql
+-- Buscar el id_mye para un vehículo específico
+SELECT mye.id_mye, b.name_brand, m.name_model, y.year_car, e.name_engine
+FROM model_year_engine mye
+JOIN models m ON mye.model_id = m.id_model
+JOIN brands b ON m.brand_id = b.id_brand
+JOIN years y ON mye.year_id = y.id_year
+JOIN engines e ON mye.engine_id = e.id_engine
+WHERE b.name_brand ILIKE 'Toyota'
+  AND m.name_model ILIKE 'Camry'
+  AND y.year_car = 2020
+ORDER BY e.name_engine;
+```
+
+### 4.2 Encontrar el `id_part` de la pieza
+
+```sql
+-- Buscar pieza por número OEM
+SELECT id_part, oem_part_number, name_part FROM parts
+WHERE oem_part_number = '04465-06090';
+```
+
+### 4.3 Crear el fitment (`vehicle_parts`)
+
+```sql
+INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, id_position_part, fitment_notes)
+VALUES (
+    12345,     -- id_mye del vehículo (del paso 4.1)
+    67890,     -- id_part de la pieza (del paso 4.2)
+    1,         -- Cantidad requerida (1 juego)
+    1,         -- Posición: 1 = front, 2 = rear (ver position_part)
+    'Fits all trim levels'  -- Notas de compatibilidad (opcional)
+);
+```
+
+### 4.4 Fitment masivo (misma pieza en varios vehículos)
+
+```sql
+-- Ejemplo: Balata 04465-06090 compatible con todos los Camry 2018-2023
+INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, id_position_part)
+SELECT mye.id_mye,
+       (SELECT id_part FROM parts WHERE oem_part_number = '04465-06090'),
+       1,    -- cantidad
+       1     -- posición: front
+FROM model_year_engine mye
+JOIN models m ON mye.model_id = m.id_model
+JOIN brands b ON m.brand_id = b.id_brand
+JOIN years y ON mye.year_id = y.id_year
+WHERE b.name_brand = 'TOYOTA'
+  AND m.name_model = 'Camry'
+  AND y.year_car BETWEEN 2018 AND 2023
+ON CONFLICT DO NOTHING;
+```
+
+### Valores de `position_part`
+
+| id_position_part | Nombre |
+|-----------------|--------|
+| 1 | front |
+| 2 | rear |
+
+> Para agregar más posiciones (left, right, upper, lower):
+> ```sql
+> INSERT INTO position_part (name_position_part) VALUES ('left'), ('right'), ('upper'), ('lower');
+> ```
+
+---
+
+## 5. Alta de Piezas Aftermarket
+
+Vincula una pieza aftermarket con su equivalente OEM y el fabricante.
+
+### 5.1 Crear pieza aftermarket (`aftermarket_parts`)
+
+```sql
+INSERT INTO aftermarket_parts (
+    oem_part_id, manufacturer_id, part_number,
+    name_aftermarket_parts, name_es,
+    id_quality_tier, price_usd, warranty_months
+) VALUES (
+    67890,           -- id_part de la pieza OEM equivalente (de tabla parts)
+    3,               -- id_manufacture del fabricante (ver manufacturers)
+    'CXD1293',       -- Número de parte aftermarket
+    'Ceramic Brake Pad Set',         -- Nombre EN
+    'Juego Balatas Cerámicas',       -- Nombre ES
+    3,               -- Calidad: 1=economy, 2=oem, 3=premium, 4=standard
+    45.99,           -- Precio USD
+    24               -- Garantía en meses
+);
+```
+
+### 5.2 Carga masiva aftermarket
+
+```sql
+INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number, name_aftermarket_parts, id_quality_tier, price_usd, warranty_months) VALUES
+    (67890, 3, 'CXD1293', 'Premium Ceramic Brake Pad', 3, 45.99, 24),
+    (67890, 5, 'MKD1293', 'Economy Semi-Metallic Brake Pad', 1, 22.50, 12),
+    (67890, 8, 'PBR1293', 'OEM Replacement Brake Pad', 2, 38.00, 18)
+ON CONFLICT DO NOTHING;
+```
+
+### Referencia de `quality_tier`
+
+| id_quality_tier | Nombre | Descripción |
+|----------------|--------|-------------|
+| 1 | economy | Económica, calidad básica |
+| 2 | oem | Calidad equivalente al original |
+| 3 | premium | Calidad superior al original |
+| 4 | standard | Calidad estándar del mercado |
+
+### Consultar fabricantes existentes
+
+```sql
+SELECT m.id_manufacture, m.name_manufacture, mt.name_type_manu AS tipo,
+       qt.name_quality AS calidad, c.name_country AS pais
+FROM manufacturers m
+LEFT JOIN manufacture_type mt ON m.id_type_manu = mt.id_type_manu
+LEFT JOIN quality_tier qt ON m.id_quality_tier = qt.id_quality_tier
+LEFT JOIN countries c ON m.id_country = c.id_country
+ORDER BY m.name_manufacture;
+```
+
+### Agregar un nuevo fabricante
+
+```sql
+INSERT INTO manufacturers (name_manufacture, id_type_manu, id_quality_tier, id_country, website)
+VALUES (
+    'BREMBO',
+    1,      -- 1=aftermarket, 2=oem
+    3,      -- 1=economy, 2=oem, 3=premium, 4=standard
+    NULL,   -- id_country (buscar en tabla countries o agregar)
+    'https://www.brembo.com'
+);
+```
+
+---
+
+## 6. Alta de Referencias Cruzadas / Intercambios
+
+Las cross-references vinculan una pieza OEM con números de parte alternativos.
+
+### 6.1 Crear referencia cruzada (`part_cross_references`)
+
+```sql
+INSERT INTO part_cross_references (part_id, cross_reference_number, id_ref_type, source_ref, notes)
+VALUES (
+    67890,              -- id_part de la pieza OEM
+    'D1293',            -- Número de referencia cruzada
+    2,                  -- Tipo: 2 = interchange (ver tabla abajo)
+    'Wagner Catalog',   -- Fuente de la referencia (opcional)
+    'Direct replacement'  -- Notas (opcional)
+);
+```
+
+### 6.2 Carga masiva de cross-references
+
+```sql
+INSERT INTO part_cross_references (part_id, cross_reference_number, id_ref_type, source_ref) VALUES
+    (67890, 'D1293', 2, 'Wagner'),         -- interchange
+    (67890, '04465-06100', 3, 'Toyota'),   -- oem_alternate (número OEM alterno)
+    (67890, 'BC1293', 1, 'Akebono'),       -- competitor
+    (67890, '04465-06080', 4, 'Toyota')    -- supersession (reemplaza a esta)
+ON CONFLICT DO NOTHING;
+```
+
+### Valores de `reference_type`
+
+| id_ref_type | Nombre | Uso |
+|------------|--------|-----|
+| 1 | competitor | Número equivalente de competidor |
+| 2 | interchange | Intercambio directo compatible |
+| 3 | oem_alternate | Número OEM alterno del mismo fabricante |
+| 4 | supersession | El número OEM que esta pieza reemplaza |
+
+---
+
+## 7. Alta de Materiales
+
+Si necesitas especificar el material de una pieza:
+
+```sql
+-- Agregar materiales
+INSERT INTO materials (name_material) VALUES
+    ('Steel'),
+    ('Aluminum'),
+    ('Ceramic'),
+    ('Rubber'),
+    ('Cast Iron'),
+    ('Stainless Steel'),
+    ('Copper'),
+    ('Plastic')
+ON CONFLICT (name_material) DO NOTHING;
+
+-- Luego, al crear una pieza, usar el id_material correspondiente:
+-- SELECT id_material FROM materials WHERE name_material = 'Ceramic';
+```
+
+---
+
+## 8. Queries Útiles para Metabase (Dashboards)
+
+### Vista completa de una pieza con todos sus datos
+
+```sql
+SELECT
+    p.oem_part_number AS "Número OEM",
+    p.name_part AS "Nombre EN",
+    p.name_es AS "Nombre ES",
+    pg.name_part_group AS "Grupo",
+    pc.name_part_category AS "Categoría",
+    p.weight_kg AS "Peso (kg)",
+    mat.name_material AS "Material",
+    COUNT(DISTINCT vp.model_year_engine_id) AS "Vehículos compatibles",
+    COUNT(DISTINCT ap.id_aftermarket_parts) AS "Opciones aftermarket",
+    COUNT(DISTINCT pcr.id_part_cross_ref) AS "Cross-references"
+FROM parts p
+JOIN part_groups pg ON p.group_id = pg.id_part_group
+JOIN part_categories pc ON pg.category_id = pc.id_part_category
+LEFT JOIN materials mat ON p.id_material = mat.id_material
+LEFT JOIN vehicle_parts vp ON vp.part_id = p.id_part
+LEFT JOIN aftermarket_parts ap ON ap.oem_part_id = p.id_part
+LEFT JOIN part_cross_references pcr ON pcr.part_id = p.id_part
+GROUP BY p.id_part, p.oem_part_number, p.name_part, p.name_es,
+         pg.name_part_group, pc.name_part_category, p.weight_kg, mat.name_material
+ORDER BY pc.name_part_category, pg.name_part_group, p.name_part;
+```
+
+### Catálogo de piezas por vehículo
+
+```sql
+SELECT
+    b.name_brand AS "Marca",
+    m.name_model AS "Modelo",
+    y.year_car AS "Año",
+    e.name_engine AS "Motor",
+    pc.name_part_category AS "Categoría",
+    pg.name_part_group AS "Grupo",
+    p.oem_part_number AS "# OEM",
+    p.name_part AS "Pieza",
+    vp.quantity_required AS "Cantidad",
+    pp.name_position_part AS "Posición"
+FROM vehicle_parts vp
+JOIN model_year_engine mye ON vp.model_year_engine_id = mye.id_mye
+JOIN models m ON mye.model_id = m.id_model
+JOIN brands b ON m.brand_id = b.id_brand
+JOIN years y ON mye.year_id = y.id_year
+JOIN engines e ON mye.engine_id = e.id_engine
+JOIN parts p ON vp.part_id = p.id_part
+JOIN part_groups pg ON p.group_id = pg.id_part_group
+JOIN part_categories pc ON pg.category_id = pc.id_part_category
+LEFT JOIN position_part pp ON vp.id_position_part = pp.id_position_part
+WHERE b.name_brand ILIKE '{{marca}}'
+  AND m.name_model ILIKE '{{modelo}}'
+ORDER BY pc.display_order, pg.display_order, p.name_part;
+```
+
+> En Metabase, `{{marca}}` y `{{modelo}}` se convierten en filtros interactivos.
+
+### Piezas aftermarket con precios
+
+```sql
+SELECT
+    p.oem_part_number AS "OEM #",
+    p.name_part AS "Pieza OEM",
+    mfr.name_manufacture AS "Fabricante",
+    ap.part_number AS "# Aftermarket",
+    ap.name_aftermarket_parts AS "Nombre",
+    qt.name_quality AS "Calidad",
+    ap.price_usd AS "Precio USD",
+    ap.warranty_months AS "Garantía (meses)"
+FROM aftermarket_parts ap
+JOIN parts p ON ap.oem_part_id = p.id_part
+JOIN manufacturers mfr ON ap.manufacturer_id = mfr.id_manufacture
+LEFT JOIN quality_tier qt ON ap.id_quality_tier = qt.id_quality_tier
+ORDER BY p.oem_part_number, qt.name_quality DESC, ap.price_usd;
+```
+
+### Cross-references de una pieza
+
+```sql
+SELECT
+    p.oem_part_number AS "OEM #",
+    p.name_part AS "Pieza",
+    pcr.cross_reference_number AS "# Referencia",
+    rt.name_ref_type AS "Tipo",
+    pcr.source_ref AS "Fuente",
+    pcr.notes AS "Notas"
+FROM part_cross_references pcr
+JOIN parts p ON pcr.part_id = p.id_part
+LEFT JOIN reference_type rt ON pcr.id_ref_type = rt.id_ref_type
+WHERE p.oem_part_number = '{{numero_oem}}'
+ORDER BY rt.name_ref_type, pcr.cross_reference_number;
+```
+
+### Estadísticas generales
+
+```sql
+SELECT
+    (SELECT COUNT(*) FROM parts) AS "Total piezas",
+    (SELECT COUNT(*) FROM vehicle_parts) AS "Total fitments",
+    (SELECT COUNT(*) FROM aftermarket_parts) AS "Total aftermarket",
+    (SELECT COUNT(*) FROM part_cross_references) AS "Total cross-refs",
+    (SELECT COUNT(*) FROM manufacturers) AS "Total fabricantes",
+    (SELECT COUNT(DISTINCT model_year_engine_id) FROM vehicle_parts) AS "Vehículos con piezas";
+```
+
+---
+
+## 9. Flujo Completo: Ejemplo Paso a Paso
+
+### Dar de alta "Balata delantera Toyota Camry 2020"
+
+**Paso 1:** Agregar la pieza OEM
+```sql
+INSERT INTO parts (oem_part_number, name_part, name_es, group_id)
+VALUES ('04465-06090', 'Front Brake Pad Set', 'Juego Balatas Delanteras', 16)
+RETURNING id_part;
+-- Resultado: id_part = 1 (anotar este ID)
+```
+
+**Paso 2:** Buscar los vehículos compatibles
+```sql
+SELECT mye.id_mye, y.year_car, e.name_engine
+FROM model_year_engine mye
+JOIN models m ON mye.model_id = m.id_model
+JOIN brands b ON m.brand_id = b.id_brand
+JOIN years y ON mye.year_id = y.id_year
+JOIN engines e ON mye.engine_id = e.id_engine
+WHERE b.name_brand = 'TOYOTA' AND m.name_model = 'Camry'
+  AND y.year_car BETWEEN 2018 AND 2023;
+-- Resultado: lista de id_mye para cada configuración
+```
+
+**Paso 3:** Crear los fitments
+```sql
+INSERT INTO vehicle_parts (model_year_engine_id, part_id, quantity_required, id_position_part)
+SELECT mye.id_mye, 1, 1, 1  -- id_part=1, qty=1, position=front
+FROM model_year_engine mye
+JOIN models m ON mye.model_id = m.id_model
+JOIN brands b ON m.brand_id = b.id_brand
+JOIN years y ON mye.year_id = y.id_year
+WHERE b.name_brand = 'TOYOTA' AND m.name_model = 'Camry'
+  AND y.year_car BETWEEN 2018 AND 2023
+ON CONFLICT DO NOTHING;
+```
+
+**Paso 4:** Agregar opciones aftermarket
+```sql
+INSERT INTO aftermarket_parts (oem_part_id, manufacturer_id, part_number, name_aftermarket_parts, id_quality_tier, price_usd, warranty_months) VALUES
+    (1, 3, 'CXD1293', 'Premium Ceramic Pad', 3, 45.99, 24),
+    (1, 5, 'MKD1293', 'Economy Brake Pad', 1, 22.50, 12);
+```
+
+**Paso 5:** Agregar cross-references
+```sql
+INSERT INTO part_cross_references (part_id, cross_reference_number, id_ref_type, source_ref) VALUES
+    (1, 'D1293', 2, 'Wagner'),
+    (1, 'BC1293', 1, 'Akebono'),
+    (1, '04465-06100', 3, 'Toyota OEM Alternate');
+```
+
+---
+
+## 10. Notas Importantes
+
+### Restricciones únicas (evitan duplicados)
+- `parts`: No tiene constraint único en `oem_part_number` (puede haber mismo OEM en diferentes grupos)
+- `vehicle_parts`: Único por `(model_year_engine_id, part_id, id_position_part)`
+- `vehicle_diagrams`: Único por `(diagram_id, model_year_engine_id)`
+- `model_year_engine`: Único por `(model_id, year_id, engine_id, trim_level)`
+
+### Búsqueda full-text
+La tabla `parts` tiene un trigger que auto-genera `search_vector` al insertar/actualizar. Esto permite búsquedas rápidas en español:
+```sql
+SELECT * FROM parts
+WHERE search_vector @@ plainto_tsquery('spanish', 'balata delantera');
+```
+
+### Para agregar nuevas categorías o grupos
+```sql
+-- Nueva categoría
+INSERT INTO part_categories (name_part_category, name_es, display_order)
+VALUES ('Interior', 'Interior', 13);
+
+-- Nuevo grupo dentro de una categoría
+INSERT INTO part_groups (category_id, name_part_group, name_es, display_order)
+VALUES (1, 'Headlights', 'Faros Delanteros', 10);
+-- (category_id 1 = Body & Lamp Assembly)
+```
+
+### Para agregar un país (para fabricantes)
+```sql
+INSERT INTO countries (name_country) VALUES ('Italy')
+ON CONFLICT (name_country) DO NOTHING;
+```
diff --git a/migrate_to_postgres.py b/migrate_to_postgres.py
new file mode 100644
index 0000000..ad4a326
--- /dev/null
+++ b/migrate_to_postgres.py
@@ -0,0 +1,470 @@
+#!/usr/bin/env python3
+"""
+Migrate data from SQLite (vehicle_database.db) to PostgreSQL (nexus_autoparts).
+
+Usage:
+    python3 migrate_to_postgres.py
+"""
+import sqlite3
+import sys
+import time
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+from config import DB_URL, SQLITE_PATH
+from models import (
+    Base, SEARCH_VECTOR_TRIGGER_SQL,
+    FuelType, BodyType, Drivetrain, Transmission, Material,
+    PositionPart, ManufactureType, QualityTier, Country,
+    ReferenceType, Shape,
+    Brand, Year, Engine, Model, ModelYearEngine,
+    PartCategory, PartGroup, Part, VehiclePart,
+    Manufacturer, AftermarketPart, PartCrossReference,
+    Diagram, VehicleDiagram, DiagramHotspot, VinCache,
+)
+
+BATCH_SIZE = 5000
+
+
+def log(msg):
+    print(f"  {msg}")
+
+
+def connect_sqlite():
+    conn = sqlite3.connect(SQLITE_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def populate_lookup(pg, sqlite_conn, LookupClass, pk_col, name_col,
+                    sql_query):
+    """Extract distinct values from SQLite and insert into a lookup table.
+    Returns a dict mapping text value → new PK id.
+    """
+    rows = sqlite_conn.execute(sql_query).fetchall()
+    values = sorted(set(r[0] for r in rows if r[0]))
+    mapping = {}
+    for i, val in enumerate(values, start=1):
+        obj = LookupClass(**{pk_col: i, name_col: val})
+        pg.add(obj)
+        mapping[val] = i
+    pg.flush()
+    log(f"  {LookupClass.__tablename__}: {len(mapping)} values")
+    return mapping
+
+
+def migrate_table(pg, sqlite_conn, query, build_obj_fn, label, batch=BATCH_SIZE):
+    """Generic batch-migrate helper."""
+    rows = sqlite_conn.execute(query).fetchall()
+    total = len(rows)
+    count = 0
+    for i in range(0, total, batch):
+        chunk = rows[i:i + batch]
+        for row in chunk:
+            obj = build_obj_fn(row)
+            if obj is not None:
+                pg.add(obj)
+        pg.flush()
+        count += len(chunk)
+        if count % 50000 == 0 or count == total:
+            log(f"  {label}: {count}/{total}")
+    return total
+
+
+def main():
+    print("=" * 60)
+    print("  NEXUS AUTOPARTS — SQLite → PostgreSQL Migration")
+    print("=" * 60)
+    t0 = time.time()
+
+    # Connect
+    print("\n[1] Connecting...")
+    sqlite_conn = connect_sqlite()
+    engine = create_engine(DB_URL, echo=False)
+    Session = sessionmaker(bind=engine)
+
+    # Drop & recreate all tables
+    print("\n[2] Creating schema...")
+    Base.metadata.drop_all(engine)
+    Base.metadata.create_all(engine)
+    log("All tables created")
+
+    pg = Session()
+
+    # ── Lookup tables ──────────────────────────────────────
+    print("\n[3] Populating lookup tables...")
+
+    fuel_map = populate_lookup(
+        pg, sqlite_conn, FuelType, "id_fuel", "name_fuel",
+        "SELECT DISTINCT fuel_type FROM engines WHERE fuel_type IS NOT NULL")
+
+    body_map = populate_lookup(
+        pg, sqlite_conn, BodyType, "id_body", "name_body",
+        "SELECT DISTINCT body_type FROM models WHERE body_type IS NOT NULL")
+
+    drive_map = populate_lookup(
+        pg, sqlite_conn, Drivetrain, "id_drivetrain", "name_drivetrain",
+        "SELECT DISTINCT drivetrain FROM model_year_engine WHERE drivetrain IS NOT NULL")
+
+    trans_map = populate_lookup(
+        pg, sqlite_conn, Transmission, "id_transmission", "name_transmission",
+        "SELECT DISTINCT transmission FROM model_year_engine WHERE transmission IS NOT NULL")
+
+    mat_map = populate_lookup(
+        pg, sqlite_conn, Material, "id_material", "name_material",
+        "SELECT DISTINCT material FROM parts WHERE material IS NOT NULL")
+
+    pos_map = populate_lookup(
+        pg, sqlite_conn, PositionPart, "id_position_part", "name_position_part",
+        "SELECT DISTINCT position FROM vehicle_parts WHERE position IS NOT NULL")
+
+    mtype_map = populate_lookup(
+        pg, sqlite_conn, ManufactureType, "id_type_manu", "name_type_manu",
+        "SELECT DISTINCT type FROM manufacturers WHERE type IS NOT NULL")
+
+    qtier_map = populate_lookup(
+        pg, sqlite_conn, QualityTier, "id_quality_tier", "name_quality",
+        """SELECT DISTINCT quality_tier FROM (
+            SELECT quality_tier FROM manufacturers WHERE quality_tier IS NOT NULL
+            UNION
+            SELECT quality_tier FROM aftermarket_parts WHERE quality_tier IS NOT NULL
+        )""")
+
+    country_map = populate_lookup(
+        pg, sqlite_conn, Country, "id_country", "name_country",
+        "SELECT DISTINCT country FROM manufacturers WHERE country IS NOT NULL")
+
+    reftype_map = populate_lookup(
+        pg, sqlite_conn, ReferenceType, "id_ref_type", "name_ref_type",
+        "SELECT DISTINCT reference_type FROM part_cross_references WHERE reference_type IS NOT NULL")
+
+    shape_map = populate_lookup(
+        pg, sqlite_conn, Shape, "id_shape", "name_shape",
+        "SELECT DISTINCT shape FROM diagram_hotspots WHERE shape IS NOT NULL")
+
+    pg.commit()
+
+    # ── Core tables ────────────────────────────────────────
+    print("\n[4] Migrating core tables...")
+
+    # brands
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM brands ORDER BY id",
+        lambda r: Brand(
+            id_brand=r["id"], name_brand=r["name"],
+            country=r["country"], founded_year=r["founded_year"],
+            created_at=r["created_at"]),
+        "brands")
+    pg.commit()
+    log(f"brands: {n} rows")
+
+    # years
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM years ORDER BY id",
+        lambda r: Year(
+            id_year=r["id"], year_car=r["year"],
+            created_at=r["created_at"]),
+        "years")
+    pg.commit()
+    log(f"years: {n} rows")
+
+    # engines
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM engines ORDER BY id",
+        lambda r: Engine(
+            id_engine=r["id"], name_engine=r["name"],
+            displacement_cc=r["displacement_cc"], cylinders=r["cylinders"],
+            id_fuel=fuel_map.get(r["fuel_type"]),
+            power_hp=r["power_hp"], torque_nm=r["torque_nm"],
+            engine_code=r["engine_code"], created_at=r["created_at"]),
+        "engines")
+    pg.commit()
+    log(f"engines: {n} rows")
+
+    # models
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM models ORDER BY id",
+        lambda r: Model(
+            id_model=r["id"], brand_id=r["brand_id"],
+            name_model=r["name"],
+            id_body=body_map.get(r["body_type"]),
+            generation=r["generation"],
+            production_start_year=r["production_start_year"],
+            production_end_year=r["production_end_year"],
+            created_at=r["created_at"]),
+        "models")
+    pg.commit()
+    log(f"models: {n} rows")
+
+    # model_year_engine
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM model_year_engine ORDER BY id",
+        lambda r: ModelYearEngine(
+            id_mye=r["id"], model_id=r["model_id"],
+            year_id=r["year_id"], engine_id=r["engine_id"],
+            trim_level=r["trim_level"],
+            id_drivetrain=drive_map.get(r["drivetrain"]),
+            id_transmission=trans_map.get(r["transmission"]),
+            created_at=r["created_at"]),
+        "model_year_engine")
+    pg.commit()
+    log(f"model_year_engine: {n} rows")
+
+    # part_categories
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM part_categories ORDER BY id",
+        lambda r: PartCategory(
+            id_part_category=r["id"],
+            name_part_category=r["name"], name_es=r["name_es"],
+            parent_id=r["parent_id"], slug=r["slug"],
+            icon_name=r["icon_name"], display_order=r["display_order"],
+            created_at=r["created_at"]),
+        "part_categories")
+    pg.commit()
+    log(f"part_categories: {n} rows")
+
+    # part_groups
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM part_groups ORDER BY id",
+        lambda r: PartGroup(
+            id_part_group=r["id"], category_id=r["category_id"],
+            name_part_group=r["name"], name_es=r["name_es"],
+            slug=r["slug"], display_order=r["display_order"],
+            created_at=r["created_at"]),
+        "part_groups")
+    pg.commit()
+    log(f"part_groups: {n} rows")
+
+    # parts (without search_vector — trigger will fill it)
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM parts ORDER BY id",
+        lambda r: Part(
+            id_part=r["id"], oem_part_number=r["oem_part_number"],
+            name_part=r["name"], name_es=r["name_es"],
+            group_id=r["group_id"],
+            description=r["description"], description_es=r["description_es"],
+            weight_kg=r["weight_kg"],
+            id_material=mat_map.get(r["material"]),
+            created_at=r["created_at"]),
+        "parts")
+    pg.commit()
+    log(f"parts: {n} rows")
+
+    # vehicle_parts
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM vehicle_parts ORDER BY id",
+        lambda r: VehiclePart(
+            id_vehicle_part=r["id"],
+            model_year_engine_id=r["model_year_engine_id"],
+            part_id=r["part_id"],
+            quantity_required=r["quantity_required"],
+            id_position_part=pos_map.get(r["position"]),
+            fitment_notes=r["fitment_notes"],
+            created_at=r["created_at"]),
+        "vehicle_parts", batch=10000)
+    pg.commit()
+    log(f"vehicle_parts: {n} rows")
+
+    # manufacturers
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM manufacturers ORDER BY id",
+        lambda r: Manufacturer(
+            id_manufacture=r["id"], name_manufacture=r["name"],
+            id_type_manu=mtype_map.get(r["type"]),
+            id_quality_tier=qtier_map.get(r["quality_tier"]),
+            id_country=country_map.get(r["country"]),
+            logo_url=r["logo_url"], website=r["website"],
+            created_at=r["created_at"]),
+        "manufacturers")
+    pg.commit()
+    log(f"manufacturers: {n} rows")
+
+    # aftermarket_parts (skip orphans with missing oem_part_id)
+    valid_part_ids = set(r[0] for r in sqlite_conn.execute("SELECT id FROM parts").fetchall())
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM aftermarket_parts ORDER BY id",
+        lambda r: AftermarketPart(
+            id_aftermarket_parts=r["id"],
+            oem_part_id=r["oem_part_id"],
+            manufacturer_id=r["manufacturer_id"],
+            part_number=r["part_number"],
+            name_aftermarket_parts=r["name"], name_es=r["name_es"],
+            id_quality_tier=qtier_map.get(r["quality_tier"]),
+            price_usd=r["price_usd"],
+            warranty_months=r["warranty_months"],
+            created_at=r["created_at"]) if r["oem_part_id"] in valid_part_ids else None,
+        "aftermarket_parts")
+    pg.commit()
+    log(f"aftermarket_parts: {n} rows")
+
+    # part_cross_references
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM part_cross_references ORDER BY id",
+        lambda r: PartCrossReference(
+            id_part_cross_ref=r["id"], part_id=r["part_id"],
+            cross_reference_number=r["cross_reference_number"],
+            id_ref_type=reftype_map.get(r["reference_type"]),
+            source_ref=r["source"], notes=r["notes"],
+            created_at=r["created_at"]),
+        "part_cross_references")
+    pg.commit()
+    log(f"part_cross_references: {n} rows")
+
+    # diagrams
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM diagrams ORDER BY id",
+        lambda r: Diagram(
+            id_diagram=r["id"], name_diagram=r["name"],
+            name_es=r["name_es"], group_id=r["group_id"],
+            image_path=r["image_path"],
+            thumbnail_path=r["thumbnail_path"],
+            display_order=r["display_order"],
+            source_diagram=r["source"],
+            created_at=r["created_at"]),
+        "diagrams")
+    pg.commit()
+    log(f"diagrams: {n} rows")
+
+    # vehicle_diagrams (skip orphans with missing diagram_id)
+    valid_diagram_ids = set(r[0] for r in sqlite_conn.execute("SELECT id FROM diagrams").fetchall())
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM vehicle_diagrams ORDER BY id",
+        lambda r: VehicleDiagram(
+            id_vehicle_dgr=r["id"], diagram_id=r["diagram_id"],
+            model_year_engine_id=r["model_year_engine_id"],
+            notes=r["notes"], created_at=r["created_at"])
+            if r["diagram_id"] in valid_diagram_ids else None,
+        "vehicle_diagrams")
+    pg.commit()
+    log(f"vehicle_diagrams: {n} rows")
+
+    # diagram_hotspots
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM diagram_hotspots ORDER BY id",
+        lambda r: DiagramHotspot(
+            id_dgr_hotspot=r["id"], diagram_id=r["diagram_id"],
+            part_id=r["part_id"], callout_number=r["callout_number"],
+            id_shape=shape_map.get(r["shape"]),
+            coords=r["coords"], created_at=r["created_at"]),
+        "diagram_hotspots")
+    pg.commit()
+    log(f"diagram_hotspots: {n} rows")
+
+    # vin_cache
+    import json
+    n = migrate_table(pg, sqlite_conn,
+        "SELECT * FROM vin_cache ORDER BY id",
+        lambda r: VinCache(
+            id=r["id"], vin=r["vin"],
+            decoded_data=json.loads(r["decoded_data"]) if r["decoded_data"] else {},
+            make=r["make"], model=r["model"], year=r["year"],
+            engine_info=r["engine_info"], body_class=r["body_class"],
+            drive_type=r["drive_type"],
+            model_year_engine_id=r["model_year_engine_id"],
+            created_at=r["created_at"], expires_at=r["expires_at"]),
+        "vin_cache")
+    pg.commit()
+    log(f"vin_cache: {n} rows")
+
+    # ── Reset sequences ───────────────────────────────────
+    print("\n[5] Resetting sequences...")
+    seq_tables = [
+        ("brands", "id_brand"),
+        ("years", "id_year"),
+        ("engines", "id_engine"),
+        ("models", "id_model"),
+        ("model_year_engine", "id_mye"),
+        ("part_categories", "id_part_category"),
+        ("part_groups", "id_part_group"),
+        ("parts", "id_part"),
+        ("vehicle_parts", "id_vehicle_part"),
+        ("manufacturers", "id_manufacture"),
+        ("aftermarket_parts", "id_aftermarket_parts"),
+        ("part_cross_references", "id_part_cross_ref"),
+        ("diagrams", "id_diagram"),
+        ("vehicle_diagrams", "id_vehicle_dgr"),
+        ("diagram_hotspots", "id_dgr_hotspot"),
+        ("vin_cache", "id"),
+        ("fuel_type", "id_fuel"),
+        ("body_type", "id_body"),
+        ("drivetrain", "id_drivetrain"),
+        ("transmission", "id_transmission"),
+        ("materials", "id_material"),
+        ("position_part", "id_position_part"),
+        ("manufacture_type", "id_type_manu"),
+        ("quality_tier", "id_quality_tier"),
+        ("countries", "id_country"),
+        ("reference_type", "id_ref_type"),
+        ("shapes", "id_shape"),
+    ]
+    with engine.connect() as conn:
+        for table, pk in seq_tables:
+            conn.execute(text(
+                f"SELECT setval(pg_get_serial_sequence('{table}', '{pk}'), "
+                f"COALESCE((SELECT MAX({pk}) FROM {table}), 0) + 1, false)"
+            ))
+        conn.commit()
+    log("All sequences reset")
+
+    # ── Full-text search trigger ──────────────────────────
+    print("\n[6] Creating search trigger & updating vectors...")
+    with engine.connect() as conn:
+        conn.execute(text(SEARCH_VECTOR_TRIGGER_SQL))
+        conn.commit()
+        # Backfill search_vector for existing rows
+        conn.execute(text("""
+            UPDATE parts SET search_vector = to_tsvector('spanish',
+                coalesce(oem_part_number, '') || ' ' ||
+                coalesce(name_part, '') || ' ' ||
+                coalesce(name_es, '') || ' ' ||
+                coalesce(description, ''))
+        """))
+        conn.commit()
+    log("Search vectors populated")
+
+    # ── Verify counts ─────────────────────────────────────
+    print("\n[7] Verifying row counts...")
+    sqlite_tables = [
+        "brands", "models", "years", "engines", "model_year_engine",
+        "part_categories", "part_groups", "parts", "vehicle_parts",
+        "manufacturers", "aftermarket_parts", "part_cross_references",
+        "diagrams", "vehicle_diagrams", "diagram_hotspots", "vin_cache"
+    ]
+    pg_tables = [
+        ("brands", "id_brand"), ("models", "id_model"),
+        ("years", "id_year"), ("engines", "id_engine"),
+        ("model_year_engine", "id_mye"),
+        ("part_categories", "id_part_category"),
+        ("part_groups", "id_part_group"), ("parts", "id_part"),
+        ("vehicle_parts", "id_vehicle_part"),
+        ("manufacturers", "id_manufacture"),
+        ("aftermarket_parts", "id_aftermarket_parts"),
+        ("part_cross_references", "id_part_cross_ref"),
+        ("diagrams", "id_diagram"),
+        ("vehicle_diagrams", "id_vehicle_dgr"),
+        ("diagram_hotspots", "id_dgr_hotspot"),
+        ("vin_cache", "id"),
+    ]
+    ok = True
+    with engine.connect() as conn:
+        for st, (pt, pk) in zip(sqlite_tables, pg_tables):
+            s_count = sqlite_conn.execute(f"SELECT COUNT(*) FROM {st}").fetchone()[0]
+            p_count = conn.execute(text(f"SELECT COUNT(*) FROM {pt}")).scalar()
+            status = "OK" if s_count == p_count else "MISMATCH"
+            if status == "MISMATCH":
+                ok = False
+            log(f"  {st}: SQLite={s_count}  PG={p_count}  [{status}]")
+
+    sqlite_conn.close()
+    elapsed = time.time() - t0
+
+    print("\n" + "=" * 60)
+    if ok:
+        print(f"  Migration completed successfully in {elapsed:.1f}s")
+    else:
+        print(f"  Migration completed with MISMATCHES in {elapsed:.1f}s")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/models.py b/models.py
new file mode 100644
index 0000000..62cc91e
--- /dev/null
+++ b/models.py
@@ -0,0 +1,410 @@
+"""
+SQLAlchemy ORM models for Nexus Autoparts.
+"""
+from sqlalchemy import (
+    Column, Integer, String, Float, Boolean, Text, DateTime, ForeignKey,
+    UniqueConstraint, Index, func, text
+)
+from sqlalchemy.dialects.postgresql import JSONB, TSVECTOR
+from sqlalchemy.orm import relationship, DeclarativeBase
+from datetime import datetime
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+# ─────────────────────────────────────────────
+# Lookup tables
+# ─────────────────────────────────────────────
+
+class FuelType(Base):
+    __tablename__ = "fuel_type"
+    id_fuel = Column(Integer, primary_key=True)
+    name_fuel = Column(String(50), nullable=False, unique=True)
+
+
+class BodyType(Base):
+    __tablename__ = "body_type"
+    id_body = Column(Integer, primary_key=True)
+    name_body = Column(String(50), nullable=False, unique=True)
+
+
+class Drivetrain(Base):
+    __tablename__ = "drivetrain"
+    id_drivetrain = Column(Integer, primary_key=True)
+    name_drivetrain = Column(String(50), nullable=False, unique=True)
+
+
+class Transmission(Base):
+    __tablename__ = "transmission"
+    id_transmission = Column(Integer, primary_key=True)
+    name_transmission = Column(String(50), nullable=False, unique=True)
+
+
+class Material(Base):
+    __tablename__ = "materials"
+    id_material = Column(Integer, primary_key=True)
+    name_material = Column(String(100), nullable=False, unique=True)
+
+
+class PositionPart(Base):
+    __tablename__ = "position_part"
+    id_position_part = Column(Integer, primary_key=True)
+    name_position_part = Column(String(50), nullable=False, unique=True)
+
+
+class ManufactureType(Base):
+    __tablename__ = "manufacture_type"
+    id_type_manu = Column(Integer, primary_key=True)
+    name_type_manu = Column(String(50), nullable=False, unique=True)
+
+
+class QualityTier(Base):
+    __tablename__ = "quality_tier"
+    id_quality_tier = Column(Integer, primary_key=True)
+    name_quality = Column(String(50), nullable=False, unique=True)
+
+
+class Country(Base):
+    __tablename__ = "countries"
+    id_country = Column(Integer, primary_key=True)
+    name_country = Column(String(100), nullable=False, unique=True)
+
+
+class ReferenceType(Base):
+    __tablename__ = "reference_type"
+    id_ref_type = Column(Integer, primary_key=True)
+    name_ref_type = Column(String(50), nullable=False, unique=True)
+
+
+class Shape(Base):
+    __tablename__ = "shapes"
+    id_shape = Column(Integer, primary_key=True)
+    name_shape = Column(String(50), nullable=False, unique=True)
+
+
+# ─────────────────────────────────────────────
+# Core tables
+# ─────────────────────────────────────────────
+
+class Brand(Base):
+    __tablename__ = "brands"
+    id_brand = Column(Integer, primary_key=True)
+    name_brand = Column(String(200), nullable=False, unique=True)
+    country = Column(String(100))
+    founded_year = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    models = relationship("Model", back_populates="brand")
+
+
+class Year(Base):
+    __tablename__ = "years"
+    id_year = Column(Integer, primary_key=True)
+    year_car = Column(Integer, nullable=False, unique=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class Engine(Base):
+    __tablename__ = "engines"
+    id_engine = Column(Integer, primary_key=True)
+    name_engine = Column(String(300), nullable=False)
+    displacement_cc = Column(Float)
+    cylinders = Column(Integer)
+    id_fuel = Column(Integer, ForeignKey("fuel_type.id_fuel"))
+    power_hp = Column(Integer)
+    torque_nm = Column(Integer)
+    engine_code = Column(String(100))
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    fuel_type = relationship("FuelType")
+
+
+class Model(Base):
+    __tablename__ = "models"
+    id_model = Column(Integer, primary_key=True)
+    brand_id = Column(Integer, ForeignKey("brands.id_brand"), nullable=False)
+    name_model = Column(String(300), nullable=False)
+    id_body = Column(Integer, ForeignKey("body_type.id_body"))
+    generation = Column(String(100))
+    production_start_year = Column(Integer)
+    production_end_year = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    brand = relationship("Brand", back_populates="models")
+    body_type = relationship("BodyType")
+
+    __table_args__ = (
+        Index("idx_models_brand", "brand_id"),
+    )
+
+
+class ModelYearEngine(Base):
+    __tablename__ = "model_year_engine"
+    id_mye = Column(Integer, primary_key=True)
+    model_id = Column(Integer, ForeignKey("models.id_model"), nullable=False)
+    year_id = Column(Integer, ForeignKey("years.id_year"), nullable=False)
+    engine_id = Column(Integer, ForeignKey("engines.id_engine"), nullable=False)
+    trim_level = Column(String(100))
+    id_drivetrain = Column(Integer, ForeignKey("drivetrain.id_drivetrain"))
+    id_transmission = Column(Integer, ForeignKey("transmission.id_transmission"))
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    model = relationship("Model")
+    year = relationship("Year")
+    engine = relationship("Engine")
+    drivetrain = relationship("Drivetrain")
+    transmission = relationship("Transmission")
+
+    __table_args__ = (
+        UniqueConstraint("model_id", "year_id", "engine_id", "trim_level",
+                         name="uq_mye_combo"),
+        Index("idx_mye_model", "model_id"),
+        Index("idx_mye_year", "year_id"),
+        Index("idx_mye_engine", "engine_id"),
+    )
+
+
+class PartCategory(Base):
+    __tablename__ = "part_categories"
+    id_part_category = Column(Integer, primary_key=True)
+    name_part_category = Column(String(200), nullable=False)
+    name_es = Column(String(200))
+    parent_id = Column(Integer, ForeignKey("part_categories.id_part_category"))
+    slug = Column(String(200), unique=True)
+    icon_name = Column(String(100))
+    display_order = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    parent = relationship("PartCategory", remote_side="PartCategory.id_part_category")
+
+    __table_args__ = (
+        Index("idx_part_categories_parent", "parent_id"),
+        Index("idx_part_categories_slug", "slug"),
+    )
+
+
+class PartGroup(Base):
+    __tablename__ = "part_groups"
+    id_part_group = Column(Integer, primary_key=True)
+    category_id = Column(Integer, ForeignKey("part_categories.id_part_category"), nullable=False)
+    name_part_group = Column(String(200), nullable=False)
+    name_es = Column(String(200))
+    slug = Column(String(200))
+    display_order = Column(Integer, default=0)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    category = relationship("PartCategory")
+
+    __table_args__ = (
+        Index("idx_part_groups_category", "category_id"),
+    )
+
+
+class Part(Base):
+    __tablename__ = "parts"
+    id_part = Column(Integer, primary_key=True)
+    oem_part_number = Column(String(100), nullable=False)
+    name_part = Column(String(300), nullable=False)
+    name_es = Column(String(300))
+    group_id = Column(Integer, ForeignKey("part_groups.id_part_group"))
+    description = Column(Text)
+    description_es = Column(Text)
+    weight_kg = Column(Float)
+    id_material = Column(Integer, ForeignKey("materials.id_material"))
+    created_at = Column(DateTime, default=datetime.utcnow)
+    search_vector = Column(TSVECTOR)
+
+    group = relationship("PartGroup")
+    material = relationship("Material")
+
+    __table_args__ = (
+        Index("idx_parts_oem", "oem_part_number"),
+        Index("idx_parts_group", "group_id"),
+        Index("idx_parts_search", "search_vector", postgresql_using="gin"),
+    )
+
+
+class VehiclePart(Base):
+    __tablename__ = "vehicle_parts"
+    id_vehicle_part = Column(Integer, primary_key=True)
+    model_year_engine_id = Column(Integer, ForeignKey("model_year_engine.id_mye"), nullable=False)
+    part_id = Column(Integer, ForeignKey("parts.id_part"), nullable=False)
+    quantity_required = Column(Integer, default=1)
+    id_position_part = Column(Integer, ForeignKey("position_part.id_position_part"))
+    fitment_notes = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    model_year_engine = relationship("ModelYearEngine")
+    part = relationship("Part")
+    position = relationship("PositionPart")
+
+    __table_args__ = (
+        UniqueConstraint("model_year_engine_id", "part_id", "id_position_part",
+                         name="uq_vehicle_part"),
+        Index("idx_vehicle_parts_mye", "model_year_engine_id"),
+        Index("idx_vehicle_parts_part", "part_id"),
+    )
+
+
+class Manufacturer(Base):
+    __tablename__ = "manufacturers"
+    id_manufacture = Column(Integer, primary_key=True)
+    name_manufacture = Column(String(200), nullable=False, unique=True)
+    id_type_manu = Column(Integer, ForeignKey("manufacture_type.id_type_manu"))
+    id_quality_tier = Column(Integer, ForeignKey("quality_tier.id_quality_tier"))
+    id_country = Column(Integer, ForeignKey("countries.id_country"))
+    logo_url = Column(String(500))
+    website = Column(String(500))
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    manufacture_type = relationship("ManufactureType")
+    quality_tier = relationship("QualityTier")
+    country = relationship("Country")
+
+
+class AftermarketPart(Base):
+    __tablename__ = "aftermarket_parts"
+    id_aftermarket_parts = Column(Integer, primary_key=True)
+    oem_part_id = Column(Integer, ForeignKey("parts.id_part"), nullable=False)
+    manufacturer_id = Column(Integer, ForeignKey("manufacturers.id_manufacture"), nullable=False)
+    part_number = Column(String(100), nullable=False)
+    name_aftermarket_parts = Column(String(300))
+    name_es = Column(String(300))
+    id_quality_tier = Column(Integer, ForeignKey("quality_tier.id_quality_tier"))
+    price_usd = Column(Float)
+    warranty_months = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    oem_part = relationship("Part")
+    manufacturer = relationship("Manufacturer")
+    quality_tier = relationship("QualityTier")
+
+    __table_args__ = (
+        Index("idx_aftermarket_oem", "oem_part_id"),
+        Index("idx_aftermarket_manufacturer", "manufacturer_id"),
+        Index("idx_aftermarket_part_number", "part_number"),
+    )
+
+
+class PartCrossReference(Base):
+    __tablename__ = "part_cross_references"
+    id_part_cross_ref = Column(Integer, primary_key=True)
+    part_id = Column(Integer, ForeignKey("parts.id_part"), nullable=False)
+    cross_reference_number = Column(String(100), nullable=False)
+    id_ref_type = Column(Integer, ForeignKey("reference_type.id_ref_type"))
+    source_ref = Column(String(200))
+    notes = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    part = relationship("Part")
+    reference_type = relationship("ReferenceType")
+
+    __table_args__ = (
+        Index("idx_cross_ref_part", "part_id"),
+        Index("idx_cross_ref_number", "cross_reference_number"),
+    )
+
+
+class Diagram(Base):
+    __tablename__ = "diagrams"
+    id_diagram = Column(Integer, primary_key=True)
+    name_diagram = Column(String(300), nullable=False)
+    name_es = Column(String(300))
+    group_id = Column(Integer, ForeignKey("part_groups.id_part_group"), nullable=False)
+    image_path = Column(String(500), nullable=False)
+    thumbnail_path = Column(String(500))
+    display_order = Column(Integer, default=0)
+    source_diagram = Column(String(200))
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    group = relationship("PartGroup")
+
+    __table_args__ = (
+        Index("idx_diagrams_group", "group_id"),
+    )
+
+
+class VehicleDiagram(Base):
+    __tablename__ = "vehicle_diagrams"
+    id_vehicle_dgr = Column(Integer, primary_key=True)
+    diagram_id = Column(Integer, ForeignKey("diagrams.id_diagram"), nullable=False)
+    model_year_engine_id = Column(Integer, ForeignKey("model_year_engine.id_mye"), nullable=False)
+    notes = Column(Text)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    diagram = relationship("Diagram")
+    model_year_engine = relationship("ModelYearEngine")
+
+    __table_args__ = (
+        UniqueConstraint("diagram_id", "model_year_engine_id", name="uq_vehicle_diagram"),
+        Index("idx_vehicle_diagrams_diagram", "diagram_id"),
+        Index("idx_vehicle_diagrams_mye", "model_year_engine_id"),
+    )
+
+
+class DiagramHotspot(Base):
+    __tablename__ = "diagram_hotspots"
+    id_dgr_hotspot = Column(Integer, primary_key=True)
+    diagram_id = Column(Integer, ForeignKey("diagrams.id_diagram"), nullable=False)
+    part_id = Column(Integer, ForeignKey("parts.id_part"))
+    callout_number = Column(Integer)
+    id_shape = Column(Integer, ForeignKey("shapes.id_shape"))
+    coords = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    diagram = relationship("Diagram")
+    part = relationship("Part")
+    shape = relationship("Shape")
+
+    __table_args__ = (
+        Index("idx_hotspots_diagram", "diagram_id"),
+        Index("idx_hotspots_part", "part_id"),
+    )
+
+
+class VinCache(Base):
+    __tablename__ = "vin_cache"
+    id = Column(Integer, primary_key=True)
+    vin = Column(String(17), nullable=False, unique=True)
+    decoded_data = Column(JSONB, nullable=False)
+    make = Column(String(100))
+    model = Column(String(100))
+    year = Column(Integer)
+    engine_info = Column(String(200))
+    body_class = Column(String(100))
+    drive_type = Column(String(100))
+    model_year_engine_id = Column(Integer, ForeignKey("model_year_engine.id_mye"))
+    created_at = Column(DateTime, default=datetime.utcnow)
+    expires_at = Column(DateTime)
+
+    __table_args__ = (
+        Index("idx_vin_cache_vin", "vin"),
+        Index("idx_vin_cache_make_model", "make", "model", "year"),
+    )
+
+
+# ─────────────────────────────────────────────
+# Full-text search trigger SQL (run after table creation)
+# ─────────────────────────────────────────────
+
+SEARCH_VECTOR_TRIGGER_SQL = """
+CREATE OR REPLACE FUNCTION parts_search_vector_update() RETURNS trigger AS $$
+BEGIN
+    NEW.search_vector := to_tsvector('spanish',
+        coalesce(NEW.oem_part_number, '') || ' ' ||
+        coalesce(NEW.name_part, '') || ' ' ||
+        coalesce(NEW.name_es, '') || ' ' ||
+        coalesce(NEW.description, '')
+    );
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DROP TRIGGER IF EXISTS trg_parts_search_vector ON parts;
+CREATE TRIGGER trg_parts_search_vector
+    BEFORE INSERT OR UPDATE ON parts
+    FOR EACH ROW
+    EXECUTE FUNCTION parts_search_vector_update();
+"""
diff --git a/requirements.txt b/requirements.txt
index 1fbfeab..68af4ea 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,3 +2,6 @@ flask==2.3.3
 requests>=2.28.0
 beautifulsoup4>=4.11.0
 lxml>=4.9.0
+sqlalchemy>=2.0
+psycopg2-binary>=2.9
+flask-sqlalchemy>=3.1