Einführung in Vektordatenbanken und die Nutzung von KI für die Suchmaschinenoptimierung

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

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

# Setzen Sie Ihre OpenAI- und Pinecone-API-Schlüssel ein.
openai_client = OpenAI(api_key='YOUR_OPENAI_API_KEY') # Instantiate OpenAI client.
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY')

# Verbindung zu einem bestehenden Pinecone-Index.
index_name = "article-index-all-ada".
index = pinecone.Index(index_name)

def generate_embeddings(text):
    """
    Erzeugt eine Einbettung für den gegebenen Text mithilfe der API von OpenAI.
    Gibt None zurück, wenn der Text ungültig ist oder ein Fehler auftritt.
    """
    try:
        if not text or not isinstance(text, str):
            raise ValueError("Input text must be a non-empty string.")

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

        clear_output(wait=True) # Ausgabe für eine frische Anzeige löschen

        if hasattr(result, 'data') and len(result.data) > 0:
            print("API Response:", result)
            return result.data[0].embedding
        else:
            raise ValueError("Invalid response from the OpenAI API. No data returned.")

    except ValueError as ve:
        print(f "ValueError: {ve}")
        return None
    except Exception as e:
        print(f "Ein Fehler trat bei der Generierung von Einbettungen auf: {e}")
        return None

# Laden Sie Ihre Artikel aus einer CSV-Datei.
df = pd.read_csv('Sample Export File.csv')

# Process each article
for idx, row in df.iterrows():
    try:
        clear_output(wait=True)
        content = row["Inhalt"].
        vector = generate_embeddings(content)

        if vector is None:
            print(f "Skipping article ID {row['ID']} due to empty or invalid embedding.")
            weiter

        index.upsert(vectors=[
            (
                row['Permalink'], # Unique ID
                vector, # The embedding
                {
                    title': row['Title'],
                    category': row['Category'],
                    type': row['Type'],
                    publish_date': row['Publish Date'],
                    publish_year': row['Publish Year']]
                }
            )
        ])
    except Exception as e:
        clear_output(wait=True)
        print(f "Fehler bei der Verarbeitung von Artikel ID {row['ID']}: {str(e)}")

print("Einbettungen werden erfolgreich in der Vektordatenbank gespeichert.")

from openai import OpenAI
from pinecone import Pinecone
from IPython.display import clear_output
from tabulate import tabulate # Import tabulate for table formatting

# Setzen Sie Ihre OpenAI- und Pinecone-API-Schlüssel.
openai_client = OpenAI(api_key='YOUR_OPENAI_API_KEY') # Instantiate OpenAI client
pinecone = Pinecone(api_key='YOUR_OPENAI_API_KEY')

# Verbindung zu einem bestehenden Pinecone-Index.
index_name = "article-index-all-ada".
index = pinecone.Index(index_name)


# Funktion zum Erzeugen von Einbettungen mithilfe der API von OpenAI.
def generate_embeddings(text):
    """
    Erzeugt eine Einbettung für einen bestimmten Text mithilfe der API von OpenAI.

    """
    try:
        if not text or not isinstance(text, str):
            raise ValueError("Input text must be a non-empty string.")

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

        # Debugging: Drucken Sie die Antwort aus, um ihre Struktur zu verstehen.
        clear_output(wait=True)
        #print("API Response:", result)

        if hasattr(result, 'data') and len(result.data) > 0:
            return result.data[0].embedding
        else:
            raise ValueError("Invalid response from the OpenAI API. No data returned.")

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

    except Exception as e:
        print(f "Ein Fehler trat bei der Generierung von Einbettungen auf: {e}")
        return None

# Funktion zur Abfrage des Pinecone-Index mit Schlüsselwörtern und Metadaten
def match_keywords_to_index(keywords):
    """
    Matches eine Liste von Schlüsselwörtern zum nächstgelegenen Artikel im Pinecone-Index, dynamisch gefiltert nach Metadaten.
    """
    Ergebnisse = []

    für keyword_pair in keywords:
        try:
            clear_output(wait=True)
            # Extrahieren Sie das Schlüsselwort und die Kategorie aus dem Teilarray.
            keyword = keyword_pair[0].
            category = keyword_pair[1]

            # Generiere embedding für das aktuelle keyword.
            vector = generate_embeddings(keyword)
            wenn vector der Wert None ist:
                print(f "Skipping keyword '{keyword}' due to embedding error.")
                weiter

            # Query the Pinecone index for the closest vector with metadata filter.
            query_results = index.query(
                vector=vector, # Die Einbettung des Schlüsselworts.
                top_k=1, # Nur den geschlossensten Treffer abrufen.
                include_metadata=True, # Metadaten in den Ergebnissen einschließen.
                filter={"category": category} # Ergebnisse dynamisch nach Metadatenkategorie filtern.
            )

            # Speichert den letzten Treffer.
            if query_results['matches']:
                closest_match = query_results['matches'][0]
                results.append({
                    'Keyword': keyword, # The searched keyword
                    Kategorie': Kategorie, # Die für die Filterung verwendete Kategorie.
                    Match Score': f"{closest_match['score']:.2f}", # Similarity score (formatiert auf 2 Dezimalstellen).
                    Titel': closest_match['metadata'].get('title', 'N/A'), # Titel des Artikels.
                    URL': closest_match['id'] # Verwendet 'id' als URL.
                })
            else:
                results.append({
                    'Keyword': keyword,
                    'Category': Kategorie,
                    Match Score': 'N/A',
                    Titel': 'No match found',
                    URL': 'N/A'
                })

        except Exception as e:
            clear_output(wait=True)
            print(f "Fehler bei der Verarbeitung des Schlüsselworts '{keyword}' mit der Kategorie '{category}': {e}")
            results.append({
                'Keyword': keyword,
                'Category': Kategorie,
                Match Score': 'Error',
                Title': 'Error occurred',
                URL': 'N/A'
            })

    return results

# Beispielverwendung: Übereinstimmungen für eine Reihe von Schlüsselwörtern und Kategorien finden
keywords = [["SEO Tools", "SEO"], ["TikTok", "TikTok"], ["SEO Consultant", "SEO"]] # Ersetze mit deinen Schlüsselwörtern und Kategorien.
matches = match_keywords_to_index(keywords)

# Zeigen Sie die Ergebnisse in einer Tabelle an.
print(tabulate(matches, headers="keys", tablefmt="fancy_grid"))

import os
import sys
import time
import numpy as np
import pandas as pd
from typing import List, Optional

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

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

# Richten Sie Ihre Google Cloud-Zugangsdaten ein.
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "config.json" # Ersetzen Sie mit Ihrer JSON-Key-Datei.
credentials, project_id = load_credentials_from_file(os.environ["GOOGLE_APPLICATION_CREDENTIALS"])

# Initialize Pinecone
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY') # Replace with your Pinecone API key.
index = pinecone.Index("article-index-vertex") # Replace with your Pinecone index name

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

def generate_embeddings(
    text: str,
    task: str = "RETRIEVAL_DOCUMENT",
    model_id: str = "text-embedding-005",
    dimensions: Optional[int] = 768
) -> Optional[List[float]]:
    if not text or not text.strip():
        print("Text input is empty. Skipping.")
        return None
    
    try:
        model = TextEmbeddingModel.from_pretrained(model_id)
        input_data = TextEmbeddingInput(text, task_type=task)
        vectors = model.get_embeddings([input_data], output_dimensionality=dimensions)
        return vectors[0].values
    except ServiceUnavailable as e:
        print(f "Vertex AI service is unavailable: {e}")
        return None
    except Exception as e:
        print(f "Fehler beim Erzeugen von Einbettungen: {e}")
        return None


# Daten aus CSV laden
data = pd.read_csv("Sample Export File.csv") # Ersetzen mit Ihrem CSV-Dateipfad

for idx, row in data.iterrows():
    try:
        permalink = str(row["Permalink"])
        content = row["Inhalt"]
        embedding = generate_embeddings(content)
        
        if not embedding:
            print(f "Skipping article ID {row['ID']} due to empty or failed embedding.")
            weiter
        
        print(f "Einbetten für {permalink}: {embedding[:5]}...")
        sys.stdout.flush()
        
        index.upsert(vectors=[
            (
                permalink,
                embedding,
                {
                    category': row['Category'],
                    title': row['Title'],
                    publish_date': row['Publish Date'],
                    type': row['Type'],
                    publish_year': row['Publish Year']]
                }
            )
        ])
        time.sleep(1) # Optional: Sleep zur Vermeidung von Geschwindigkeitsbegrenzungen.
    except Exception as e:
        print(f "Fehler bei der Verarbeitung von Artikel ID {row['ID']}: {e}")

print("Alle Einbettungen werden in der Vektordatenbank gespeichert.")

import os
import pandas as pd
from google.cloud import aiplatform
from google.auth import load_credentials_from_file
from google.api_core.exceptions import ServiceUnavailable
from vertexai.language_models import TextEmbeddingModel

from pinecone import Pinecone
from tabulate import tabulate # Für Tabellenformatierungen

# Richten Sie Ihre Google Cloud-Zugangsdaten ein.
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "config.json" # Ersetzen Sie mit Ihrer JSON-Key-Datei.
credentials, project_id = load_credentials_from_file(os.environ["GOOGLE_APPLICATION_CREDENTIALS"])

# Initialize Pinecone client
pinecone = Pinecone(api_key='YOUR_PINECON_API_KEY') # Fügen Sie Ihren Pinecone API-Schlüssel hinzu.
index_name = "article-index-vertex" # Ersetzen Sie mit Ihrem Pinecone Indexnamen.
index = pinecone.Index(index_name)

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

def generate_embeddings(
    text: str,
    model_id: str = "text-embedding-005".
) -> list:
    """
    Generiert Einbettungen für den eingegebenen Text unter Verwendung des Einbettungsmodells von Google Vertex AI.
    Gibt None zurück, wenn der Text leer ist oder ein Fehler auftritt.
    """
    if not text or not text.strip():
        print("Text-Eingabe ist leer. Skipping.")
        return None

    try:
        model = TextEmbeddingModel.from_pretrained(model_id)
        vector = model.get_embeddings([text]) # Removed 'task_type' and 'output_dimensionality'.
        return vector[0].values
    except ServiceUnavailable as e:
        print(f "Vertex AI service is unavailable: {e}")
        return None
    except Exception as e:
        print(f "Fehler beim Erzeugen von Einbettungen: {e}")
        return None


def match_keywords_to_index(keywords):
    """
    Matches eine Liste von keyword-category-Paaren zu den nächstgelegenen Artikeln im Pinecone-Index,
    Filterung nach Metadaten, wenn angegeben.
    """
    results = []

    für keyword_pair in keywords:
        keyword = keyword_pair[0].
        category = keyword_pair[1].

        try:
            keyword_vector = generate_embeddings(keyword)

            if not keyword_vector:
                print(f "No embedding generated for keyword '{keyword}' in category '{category}'.").
                results.append({
                    'Keyword': keyword,
                    'Category': Kategorie,
                    Match Score': 'Error/Empty',
                    Titel': 'No match',
                    URL': 'N/A'
                })
                weiter

            query_results = index.query(
                vector=keyword_vector,
                top_k=1,
                include_metadata=True,
                filter={"category": category}
            )

            if query_results['matches']:
                closest_match = query_results['matches'][0].
                results.append({
                    'Keyword': keyword,
                    'Category': category,
                    Match Score': f"{closest_match['score']:.2f}",
                    Titel': closest_match['metadata'].get('title', 'N/A'),
                    URL': closest_match['id']]
                })
            else:
                results.append({
                    'Keyword': keyword,
                    'Category': Kategorie,
                    Match Score': 'N/A',
                    Titel': 'No match found',
                    URL': 'N/A'
                })

        except Exception as e:
            print(f "Fehler bei der Verarbeitung des Schlüsselworts '{keyword}' mit der Kategorie '{category}': {e}")
            results.append({
                'Keyword': keyword,
                'Category': Kategorie,
                Match Score': 'Error',
                Title': 'Error occurred',
                URL': 'N/A'
            })

    return results

# Beispiel Verwendung:
keywords = [["SEO Tools", "Tools"], ["TikTok", "TikTok"], ["SEO Consultant", "SEO"]]

matches = match_keywords_to_index(keywords)

# Die Ergebnisse in einer Tabelle anzeigen.
print(tabulate(matches, headers="keys", tablefmt="fancy_grid"))