Introducción a las bases de datos vectoriales y al uso de la IA para la referenciación

pip install openai google-cloud-aiplatform google-auth pandas pinecone-client tabulate ipython numpy

importar pandas como pd
from openai import OpenAI
from pinecone import Pinecone
from IPython.display import clear_output

# Configura tus claves API de OpenAI y Pinecone
openai_client = OpenAI(api_key='YOUR_OPENAI_API_KEY') # Instanciar el cliente OpenAI
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY')

# Conectar a un índice Pinecone existente
index_name = "articulo-index-todo-ada"
index = pinecone.Index(nombre_índice)

def generar_incrustaciones(texto):
    """
    Genera una incrustación para el texto dado utilizando la API de OpenAI.
    Devuelve None si el texto no es válido o se produce un error.
    """
    intentar:
        if not text or not isinstance(text, str):
            raise ValueError("El texto de entrada debe ser una cadena no vacía.")

        result = openai_client.embeddings.create(
            input=texto,
            model="text-embedding-ada-002"
        )

        clear_output(wait=True) # Borrar salida para una nueva visualización

        if hasattr(result, 'data') and len(result.data) > 0:
            print("Respuesta API:", resultado)
            return resultado.datos[0].incrustación
        else:
            raise ValueError("Respuesta no válida de la API OpenAI. No se han devuelto datos.")

    except ValueError as ve:
        print(f "ValueError: {ve}")
        return None
    excepto Exception como e:
        print(f "Se ha producido un error al generar incrustaciones: {e}")
        return None

# Carga tus artículos desde un CSV
df = pd.read_csv('Ejemplo de archivo de exportación.csv')

# Procesa cada artículo
para idx, fila en df.iterrows():
    try:
        clear_output(wait=True)
        contenido = fila["Contenido"]
        vector = generate_embeddings(contenido)

        si vector es None
            print(f "Skipping article ID {row['ID']} due to empty or invalid embedding.")
            continuar

        index.upsert(vectores=[
            (
                fila['Permalink'], # ID único
                vector, # La incrustación
                {
                    title': fila['Título'],
                    'category': fila['Categoría'],
                    'type': fila['Tipo'],
                    'publish_date': fila['Fecha de publicación'],
                    publish_year': fila['Año de publicación']
                }
            )
        ])
    except Exception as e:
        clear_output(wait=True)
        print(f "Error al procesar el ID del artículo {fila['ID']}: {str(e)}")

print("Las incrustaciones se han almacenado correctamente en la base de datos de vectores.")

from openai import OpenAI
from pinecone import Pinecone
from IPython.display import clear_output
from tabulate import tabulate # Importar tabulate para formatear tablas

# Configura tus claves API de OpenAI y Pinecone
openai_client = OpenAI(api_key='YOUR_OPENAI_API_KEY') # Instanciar el cliente OpenAI
pinecone = Pinecone(api_key='YOUR_OPENAI_API_KEY')

# Conectar a un índice Pinecone existente
index_name = "articulo-index-todo-ada"
index = pinecone.Index(nombre_índice)


# Función para generar incrustaciones utilizando la API de OpenAI
def generar_incrustaciones(texto):
    """
    Genera una incrustación para un texto dado utilizando la API de OpenAI.

    """
    prueba:
        if not text or not isinstance(text, str):
            raise ValueError("El texto de entrada debe ser una cadena no vacía.")

        result = openai_client.embeddings.create(
            input=texto,
            model="text-embedding-ada-002"
        )

        # Debugging: Imprime la respuesta para entender su estructura
        clear_output(wait=True)
        #print("Respuesta API:", resultado)

        if hasattr(result, 'data') and len(result.data) > 0:
            return resultado.datos[0].incrustación
        else:
            raise ValueError("Respuesta no válida de la API OpenAI. No se han devuelto datos.")

    except ValueError as ve:
        print(f "ValueError: {ve}")
        return Ninguno

    excepto Exception como e:
        print(f "Se ha producido un error al generar incrustaciones: {e}")
        return None

# Función para consultar el índice Pinecone con palabras clave y metadatos
def match_keywords_to_index(keywords):
    """
    Compara una lista de palabras clave con el artículo más cercano en el índice Pinecone, filtrando por metadatos dinámicamente.
    """
    resultados = []

    para par_palabra_clave en palabras_clave:
        try:
            clear_output(wait=True)
            # Extrae la palabra clave y la categoría de la submatriz
            palabra clave = par_palabras_clave[0]
            categoría = par_palabras_clave[1]

            # Genera la incrustación de la palabra clave actual
            vector = generar_incrustaciones(palabra_clave)
            si vector es None
                print(f "Se omite la palabra clave '{palabra clave}' debido a un error de incrustación.")
                continuar

            # Consulta el índice Pinecone en busca del vector más cercano con filtro de metadatos
            query_results = index.query(
                vector=vector, # La incrustación de la palabra clave
                top_k=1, # Recuperar sólo la coincidencia más cercana
                include_metadata=True, # Incluir metadatos en los resultados
                filter={"category": categoría} # Filtrar los resultados por categoría de metadatos de forma dinámica
            )

            # Almacenar la coincidencia más cercana
            if consulta_resultados['coincidencias']:
                coincidencia_más_cercana = query_results['coincidencias'][0]
                results.append({
                    'Palabra clave': palabra clave, # La palabra clave buscada
                    Categoría": category, # Categoría utilizada para el filtrado
                    'Match Score': f"{closest_match['score']:.2f}", # Puntuación de similitud (con 2 decimales)
                    'Title': closest_match['metadata'].get('title', 'N/A'), # Título del artículo
                    'URL': closest_match['id'] # Usando 'id' como URL
                })
            else:
                results.append({
                    'Palabra clave': palabra clave,
                    Categoría: category,
                    'Match Score': 'N/A',
                    'Título': 'No se ha encontrado ninguna coincidencia',
                    'URL': 'N/A
                })

        except Exception as e:
            clear_output(wait=True)
            print(f "Error al procesar la palabra clave '{palabra clave}' con la categoría '{categoría}': {e}")
            results.append({
                Palabra clave': palabra clave,
                Categoría: categoría,
                Puntuación': 'Error',
                'Título': 'Se ha producido un error',
                'URL': 'N/A
            })

    devolver resultados

# Ejemplo de uso: Buscar coincidencias para una matriz de palabras clave y categorías
keywords = [["Herramientas SEO", "SEO"], ["TikTok", "TikTok"], ["Consultor SEO", "SEO"]] # Reemplace con sus palabras clave y categorías
matches = match_keywords_to_index(palabras clave)

# Muestra los resultados en una tabla
print(tabulate(matches, headers="keys", tablefmt="fancy_grid"))

importar os
importar sys
import tiempo
import numpy como np
import pandas como pd
from typing import Lista, Opcional

from google.auth import carga_credenciales_desde_archivo
from google.cloud import aiplatform
from google.api_core.exceptions import ServiceUnavailable

from pinecone import Pinecone
from vertexai.language_models import TextEmbeddingModel, TextEmbeddingInput

# Configura tus credenciales de Google Cloud
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "config.json" # Sustitúyelo por tu archivo de claves JSON
credentials, project_id = load_credentials_from_file(os.environ["GOOGLE_APPLICATION_CREDENTIALS"])

# Inicializar Pinecone
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY') # Reemplazar con su clave API Pinecone
index = pinecone.Index("article-index-vertex") # Sustituir por el nombre de su índice Pinecone

# Inicializar Vertex AI
aiplatform.init(project=project_id, credentials=credenciales, location="us-central1")

def generar_embeddings(
    texto: str,
    tarea: str = "RETRIEVAL_DOCUMENT",
    model_id: str = "text-embedding-005",
    dimensiones: Optional[int] = 768
) -> Opcional[Lista[float]]:
    if not text or not text.strip():
        print("La entrada de texto está vacía. Se omite.")
        return None
    
    probar:
        model = TextEmbeddingModel.from_pretrained(model_id)
        input_data = TextEmbeddingInput(text, task_type=tarea)
        vectores = model.get_embeddings([datos_entrada], dimensionalidad_salida=dimensiones)
        return vectores[0].valores
    except ServiceUnavailable as e:
        print(f "El servicio de IA de vértices no está disponible: {e}")
        return Ninguno
    except Exception as e:
        print(f "Error al generar incrustaciones: {e}")
        return None


# Cargar datos desde CSV
data = pd.read_csv("Archivo de exportación de ejemplo.csv") # Sustituir por la ruta del archivo CSV

for idx, row in data.iterrows():
    try:
        permalink = str(fila["Permalink"])
        contenido = fila["Contenido"]
        incrustación = generate_embeddings(contenido)
        
        if not embedding:
            print(f "Skipping article ID {row['ID']} due to empty or failed embedding.")
            continuar
        
        print(f "Incrustación para {permalink}: {incrustación[:5]}...")
        sys.stdout.flush()
        
        index.upsert(vectores=[
            (
                permalink,
                incrustación,
                {
                    categoría: fila['Categoría'],
                    'title': fila['Título'],
                    'publish_date': fila['Fecha de publicación'],
                    'type': fila['Tipo'],
                    publish_year': fila['Año de publicación']
                }
            )
        ])
        time.sleep(1) # Opcional: Sleep para evitar límites de velocidad
    except Exception as e:
        print(f "Error al procesar el ID del artículo {fila['ID']}: {e}")

print("Todas las incrustaciones están almacenadas en la base de datos de vectores.")

importar os
importar pandas como pd
from google.cloud import aiplatform
from google.auth import carga_credenciales_desde_archivo
from google.api_core.exceptions import ServiceUnavailable
from vertexai.language_models import TextEmbeddingModel

from pinecone import Pinecone
from tabulate import tabulate # Para el formato de tablas

# Configura tus credenciales de Google Cloud
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "config.json" # Sustitúyelo por tu archivo de claves JSON
credentials, project_id = load_credentials_from_file(os.environ["GOOGLE_APPLICATION_CREDENTIALS"])

# Inicializar cliente Pinecone
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY') # Añade tu clave API Pinecone
index_name = "article-index-vertex" # Sustitúyalo por el nombre de su índice Pinecone
index = pinecone.Index(nombre_índice)

# Inicializar Vertex AI
aiplatform.init(project=project_id, credentials=credenciales, location="us-central1")

def generar_embeddings(
    texto: str,
    model_id: str = "text-embedding-005"
) -> list:
    """
    Genera incrustaciones para el texto de entrada utilizando el modelo de incrustación de Google Vertex AI.
    Devuelve None si el texto está vacío o se produce un error.
    """
    if not text or not text.strip():
        print("El texto de entrada está vacío. Se omite.")
        return Ninguno

    probar:
        model = TextEmbeddingModel.from_pretrained(model_id)
        vector = model.get_embeddings([text]) # Eliminados 'task_type' y 'output_dimensionality'
        return vector[0].values
    except ServiceUnavailable as e:
        print(f "El servicio Vertex AI no está disponible: {e}")
        return None
    except Exception as e:
        print(f "Error al generar incrustaciones: {e}")
        return None


def emparejar_palabras_con_índice(palabras_clave):
    """
    Empareja una lista de pares palabra clave-categoría con los artículos más cercanos en el índice Pinecone,
    filtrando por metadatos si se especifica.
    """
    resultados = []

    para par_palabra_clave en palabras_clave:
        palabra_clave = par_palabra_clave[0]
        categoría = par_palabras_clave[1]

        probar:
            vector_palabra_clave = generar_incrustaciones(palabra_clave)

            if not vector_palabra_clave:
                print(f "No embedding generated for keyword '{keyword}' in category '{category}'.")
                results.append({
                    Palabra clave: palabra clave,
                    Categoría: categoría,
                    'Puntuación de coincidencia': 'Error/Vacío',
                    'Título': 'Sin coincidencia',
                    'URL': 'N/A
                })
                continuar

            query_results = index.query(
                vector=vector_palabra_clave,
                top_k=1,
                include_metadata=True,
                filter={"categoría": categoría}
            )

            if consulta_resultados['coincidencias']:
                coincidencia_más_cercana = query_results['coincidencias'][0]
                results.append({
                    Palabra clave: palabra clave,
                    Categoría: categoría,
                    'Puntuación': f"{closest_match['score']:.2f}",
                    'Título': closest_match['metadata'].get('title', 'N/A'),
                    'URL': closest_match['id']
                })
            else:
                results.append({
                    'Palabra clave': palabra clave,
                    Categoría: category,
                    'Match Score': 'N/A',
                    'Título': 'No se ha encontrado ninguna coincidencia',
                    'URL': 'N/A
                })

        except Exception as e:
            print(f "Error al procesar la palabra clave '{palabra clave}' con la categoría '{categoría}': {e}")
            results.append({
                Palabra clave': palabra clave,
                Categoría: categoría,
                Puntuación': 'Error',
                'Título': 'Se ha producido un error',
                'URL': 'N/A
            })

    devolver resultados

# Ejemplo de uso:
keywords = [["Herramientas SEO", "Herramientas"], ["TikTok", "TikTok"], ["Consultor SEO", "SEO"]]

matches = match_keywords_to_index(palabras clave)

# Mostrar los resultados en una tabla
print(tabulate(matches, headers="keys", tablefmt="fancy_grid"))