Knowledge Graphs: The Secret Weapon for Superior RAG Applications

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Sample player descriptions
players = [
    "Patrick Mahomes is a quarterback for the Kansas City Chiefs, known for his strong arm and playmaking ability.",
    "Derrick Henry is a running back for the Tennessee Titans, famous for his power running and consistency.",
    "Davante Adams is a wide receiver for the Las Vegas Raiders, recognized for his excellent route running and catching ability.",
    "Tom Brady is a veteran quarterback known for his leadership and game management.",
    "Alvin Kamara is a running back for the New Orleans Saints, known for his agility and pass-catching ability."
]

# Vectorize player descriptions
vectorizer = TfidfVectorizer()
player_vectors = vectorizer.fit_transform(players)

# Function to retrieve the most relevant player
def retrieve_player(query, player_vectors, players):
    query_vector = vectorizer.transform([query])
    similarities = cosine_similarity(query_vector, player_vectors).flatten()
    most_similar_player_index = np.argmax(similarities)
    return players[most_similar_player_index]

# Function to generate a recommendation
def generate_recommendation(query, retrieved_player):
    response = f"Query: {query}\n\nRecommended Player: {retrieved_player}\n\nRecommendation: Based on the query, the recommended player is a good fit for your team."
    return response

# Example query
query = "I need a versatile player."
retrieved_player = retrieve_player(query, player_vectors, players)
response = generate_recommendation(query, retrieved_player)

print(response)

python ragwithoutknowledgegraph.py
Query: I need a versatile player.

Recommended Player: Patrick Mahomes is a quarterback for the Kansas City Chiefs, known for his strong arm and playmaking ability.

Recommendation: Based on the query, the recommended player is a good fit for your team.

import rdflib
from rdflib import Graph, Literal, RDF, URIRef, Namespace

# Initialize the graph
g = Graph()
ex = Namespace("http://example.org/")

# Define players as subjects
patrick_mahomes = URIRef(ex.PatrickMahomes)
derrick_henry = URIRef(ex.DerrickHenry)
davante_adams = URIRef(ex.DavanteAdams)
tom_brady = URIRef(ex.TomBrady)
alvin_kamara = URIRef(ex.AlvinKamara)

# Add player attributes to the graph
g.add((patrick_mahomes, RDF.type, ex.Player))
g.add((patrick_mahomes, ex.team, Literal("Kansas City Chiefs")))
g.add((patrick_mahomes, ex.position, Literal("Quarterback")))
g.add((patrick_mahomes, ex.skills, Literal("strong arm, playmaking")))

g.add((derrick_henry, RDF.type, ex.Player))
g.add((derrick_henry, ex.team, Literal("Tennessee Titans")))
g.add((derrick_henry, ex.position, Literal("Running Back")))
g.add((derrick_henry, ex.skills, Literal("power running, consistency")))

g.add((davante_adams, RDF.type, ex.Player))
g.add((davante_adams, ex.team, Literal("Las Vegas Raiders")))
g.add((davante_adams, ex.position, Literal("Wide Receiver")))
g.add((davante_adams, ex.skills, Literal("route running, catching ability")))

g.add((tom_brady, RDF.type, ex.Player))
g.add((tom_brady, ex.team, Literal("Retired")))
g.add((tom_brady, ex.position, Literal("Quarterback")))
g.add((tom_brady, ex.skills, Literal("leadership, game management")))

g.add((alvin_kamara, RDF.type, ex.Player))
g.add((alvin_kamara, ex.team, Literal("New Orleans Saints")))
g.add((alvin_kamara, ex.position, Literal("Running Back")))
g.add((alvin_kamara, ex.skills, Literal("versatility, agility, pass-catching")))

# Function to retrieve the most relevant player using the knowledge graph
def retrieve_player_kg(query, graph):
    # Define synonyms for key skills
    synonyms = {
        "versatile": ["versatile", "versatility"],
        "agility": ["agility"],
        "pass-catching": ["pass-catching"],
        "strong arm": ["strong arm"],
        "playmaking": ["playmaking"],
        "leadership": ["leadership"],
        "game management": ["game management"]
    }
    
    # Extract key terms from the query and match with synonyms
    key_terms = []
    for term, syns in synonyms.items():
        if any(syn in query.lower() for syn in syns):
            key_terms.extend(syns)
    
    filters = " || ".join([f"contains(lcase(str(?skills)), '{term}')" for term in key_terms])
    
    query_string = f"""
    PREFIX ex: <http://example.org/>
    SELECT ?player ?team ?skills WHERE {{
        ?player ex:skills ?skills .
        ?player ex:team ?team .
        FILTER ({filters})
    }}
    """
    
   
    
    qres = graph.query(query_string)
  
    
    best_match = None
    best_score = -1
    
    for row in qres:
        skill_set = row.skills.lower().split(', ')
        score = sum(term in skill_set for term in key_terms)
        if score > best_score:
            best_score = score
            best_match = row
    
    if best_match:
        return f"Player: {best_match.player.split('/')[-1]}, Team: {best_match.team}, Skills: {best_match.skills}"
    
    return "No relevant player found."

# Function to generate a recommendation
def generate_recommendation_kg(query, retrieved_player):
    response = f"Query: {query}\n\nRecommended Player: {retrieved_player}\n\nRecommendation: Based on the query, the recommended player is a good fit for your team."
    return response

# Example query
query = "I need a versatile player."
retrieved_player = retrieve_player_kg(query, g)
response = generate_recommendation_kg(query, retrieved_player)

print(response)