Eine intelligentere und schnellere Möglichkeit, Ihre Steam-Bibliothek zu durchsuchen Du kennst das Gefühl. Du suchst nach einem Spiel, das strategisch, co-op, vielleicht mit einem sci-fi-Thema ist. Du bekommst eine Wand von Titeln, die Art von Übereinstimmung. Was du wolltest, war eine Shortlist, die wirklich die Stimmung hinter deinen Worten erfasst. In diesem Leitfaden zeigen wir, wie man genau das baut, indem Superlinked mit LlamaIndex gepaart wird. Das Ergebnis ist ein benutzerdefinierter Steam-Spiel-Retriever, der Genre plus Beschreibung plus Tags versteht und Antworten in Millisekunden liefert. * der Möchten Sie dies auf Ihren Daten mit echten Abfragen und Latenzzahlen sehen? . Get in touch Gehen Sie in Berührung Gehen Sie in Berührung Tsch; Dr Benutzerdefinierte Retriever geben Ihnen die Kontrolle über den Domain-Kontext, Metadaten und Ranking-Logik. Sie übertreffen die generische Ähnlichkeitssuche, wenn Abfragen unkompliziert oder mit schwerem Jargon sind. Superlinked kombiniert mehrere Textfelder in einen semantischen Raum und führt Abfragen im Gedächtnis für schnelle Ergebnisse aus. LlamaIndex bietet die saubere Retriever-Schnittstelle und schließt direkt in die Abfrage-Engine und die Antwortssynthese ein. Es gibt eine offizielle Superlinked Retriever-Integration für LlamaIndex, die Sie importieren und verwenden können. Offizieller Superlinked Retriever für LlamaIndex Superlinked integriert mit LlamaIndex über den offiziellen auf LlamaHub aufgeführt, so dass Sie Superlinked mit einer einfachen Installation und Dann schließen Sie es in eine Erfahren Sie mehr über die Die Klassen- und Konstruktorparameter sind in der LlamaIndex API-Referenz dokumentiert. SuperlinkedRetriever from llama_index.retrievers.superlinked import SuperlinkedRetriever RetrieverQueryEngine . Offizielle Integrationsseite . Offizielle Integrationsseite Offizielle Integrationsseite pip install llama-index-retrievers-superlinked from llama_index.retrievers.superlinked import SuperlinkedRetriever # sl_app: a running Superlinked App # query_descriptor: a Superlinked QueryDescriptor that describes your query plan retriever = SuperlinkedRetriever( sl_client=sl_app, sl_query=query_descriptor, page_content_field="text", query_text_param="query_text", metadata_fields=None, top_k=10, ) nodes = retriever.retrieve("strategic co-op sci fi game") Möchten Sie es lieber von Hand aufbauen oder die Logik weiter anpassen? Why Superlinked + LlamaIndex? Warum Superlinked + LlamaIndex? Das Ziel ist einfach: Nehmen Sie die Stärken von Superlinked für die Multi-Field-Erfassung und verpacken Sie sie, damit Entwickler in realen RAG-Systemen anwenden und erweitern können. Superlinked hilft Ihnen, ausdrucksstarke Vektorräume und Abfragen zu definieren, die Felder wie Name, Beschreibung und Genre in eine einzige semantische Ansicht mischen. Sie können auch folgen in mit den gleichen Bausteinen aus den Superlinked-Notebooks. Google ist Kolben Google ist Kolben Kolben Warum Custom Retrievers zählen Gerüstet für Ihre Domain – Generische Retriever sind gut für den allgemeinen Gebrauch, aber sie haben die Tendenz, die subtilen Dinge zu verpassen. Denken Sie an Jargon, Abkürzungen oder domain-spezifische Ausdrücke, diese werden normalerweise nicht aufgeholt, es sei denn, Ihr Retriever weiß, was zu suchen ist. Works Beyond Just Text – Die meisten realen Daten sind nicht nur einfacher Text. Sie haben oft auch Metadaten und Tags. Zum Beispiel kümmern wir uns in einem Spieleempfehlungssystem nicht nur um die Spielbeschreibung. Wir möchten auch in Genres, Tags, Benutzerbewertungen und mehr berücksichtigen. Denken Sie an diese Logik: jemand, der nach einem „Strategie-Co-op-Spiel mit Sci-Fi-Elementen“ sucht, wird nicht weit mit Text-only-Matching kommen. Benutzerdefinierte Filter- und Ranking-Logik – Manchmal möchten Sie Ihre eigenen Regeln auf die Art und Weise anwenden, wie Dinge erzielt oder gefiltert werden. Vielleicht möchten Sie neuere Inhalte priorisieren oder Ergebnisse bestrafen, die bestimmte Qualitätsschwellenwerte nicht erfüllen. Performance Gains – Lassen Sie uns real sein: Allgemeinzweck-Lösungen sind so konzipiert, dass sie für jeden „okay“ funktionieren, nicht gut für Sie. Wenn Sie Ihre Daten und Ihre Zugriffsmuster kennen, können Sie Ihren Retriever optimieren, um schneller zu laufen, besser zu rangieren und unnötigen Lärm in den Ergebnissen zu reduzieren. Implementierung Breakdown Teil 1: Kernabhängigkeiten und Importe import time import logging import pandas as pd from typing import List from llama_index.core.retrievers import BaseRetriever from llama_index.core.schema import NodeWithScore, QueryBundle, TextNode from llama_index.core.query_engine import RetrieverQueryEngine from llama_index.core.response_synthesizers import get_response_synthesizer from llama_index.core import Settings from llama_index.llms.openai import OpenAI import superlinked.framework as sl Die Importstruktur zeigt unseren Hybridansatz: LlamaIndex Core: Bereitstellt die Abstraktionsschicht zum Abrufen Superlinked Framework: Handhabt vektorische Berechnung und semantische Suche Pandas: Verwalten von Datenvorverarbeitung und Manipulation Teil 2: Verstehen von LlamaIndex Custom Retrievers Bevor Sie in unsere Superlinked-Implementierung eintauchen, ist es wichtig zu verstehen, wie die benutzerdefinierte Retriever-Architektur von LlamaIndex funktioniert und warum sie so leistungsstark ist, um Domain-spezifische RAG-Anwendungen zu erstellen. BaseRetriever Abstraktion LlamaIndex bietet einen Abstract Die Schönheit dieses Designs liegt in seiner Einfachheit – jeder benutzerdefinierte Retriever muss nur eine Kernmethode implementieren: BaseRetriever from abc import abstractmethod from llama_index.core.retrievers import BaseRetriever from llama_index.core.schema import NodeWithScore, QueryBundle class BaseRetriever: @abstractmethod def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]: """Retrieve nodes given query.""" pass Der Grund hier ist die Anwesenheit des Retrieval-Protokolls vom LlamaIndex. Da dieses "Retrieval-Protokoll" es einfach macht, verschiedene Backends oder Strategien anzubringen, ohne den Rest Ihres Systems zu berühren. Input: QueryBundle This is the query object passed into your retriever. At minimum, it contains the user's raw query string (e.g., "sci-fi strategy games"). But it can also include extra metadata like filters, embeddings, or user preferences. Basically, anything that might help shape a more relevant response. Output: List[NodeWithScore] The retriever returns a list of nodes—these are your chunks of content, documents, or data entries—each paired with a relevance score. The higher the score, the more relevant the node is to the query. This list is what gets passed downstream to the LLM or other post-processing steps. As in our case, we are plugging on the Processing: Backend-Agnostic Here’s the cool part: how you get from query to result is totally up to you. You can use a vector database, a traditional search engine, a REST API, or even something handcrafted for your specific use case. This decouples logic and gives you full control over the retrieval stack. Warum ist das wichtig? Diese Abstraktion ist sauber und Es bedeutet, dass Sie können: mächtig Kombinieren Sie mehrere Strategien – Verwenden Sie bei Bedarf eine dichte Vektorsuche und Keyword-Filterung zusammen. Leicht A/B-Tests durchführen – Vergleichen Sie verschiedene Retriever, um zu sehen, was für Ihre Benutzer bessere Ergebnisse liefert. Plug in jeden Agent oder Tool – Ob Sie einen Chatbot, eine Such-UI oder ein vollwertiges Agentensystem aufbauen, diese Retriever-Schnittstelle ist einfach. Denken Sie an das Recovery-Protokoll als den API-Vertrag zwischen Ihrem "Recovery-Gehirn" und allem anderen. Plugging Superlinked in LlamaIndex Okay, so dass die Klasse ist im Grunde unser Go-to-Tool, um intelligente, semantische Spielempfehlungen zu geben. Wir werden mit einem schnellen Blick darauf beginnen, wie es zusammengestellt ist, und dann später tiefer in jeden Teil eintauchen, um wirklich zu sehen, was dieses Ding zittert. SuperlinkedSteamGamesRetriever Zuerst oben ist die , denken Sie darüber nach als Grundlage. Es ist das, was alles organisiert und zuverlässig hält. Wir haben wichtige Details wie , der , der und Dies hält alle Spielinformationen sauber und konsistent, und es schließt sich direkt in die Pipeline von Superlinked ein, damit alles reibungslos fließt. schema definition GameSchema game_number name desc_snippet genre class GameSchema(sl.Schema): game_number: sl.IdField name: sl.String desc_snippet: sl.String game_details: sl.String languages: sl.String genre: sl.String game_description: sl.String original_price: sl.Float discount_price: sl.Float combined_text: sl.String # New field for combined text self.game = GameSchema() Nächstes oben ist die Hier findet die Magie der semantischen Suche statt. Modell, um eine Reihe von Spielinformationen (wie Name, Beschreibung, Genre usw.) in dichte Vektorrepräsentationen zu verwandeln. Grundsätzlich glättet es all diesen Text zusammen in etwas, das das Modell verstehen kann. Also, wenn jemand nach etwas wie "Open-World-Abenteuer" sucht, kann er Spiele finden, die tatsächlich zu dieser Atmosphäre passen, nicht nur solche mit diesen exakten Wörtern. text similarity space sentence-transformers/all-mpnet-base-v2 bedeutet self.text_space = sl.TextSimilaritySpace( text=self.game.combined_text, model="sentence-transformers/all-mpnet-base-v2" ) Die Es nimmt verschiedene Informationen (wie den Namen des Spiels, die Beschreibung, das Genre und mehr) und zerschmettert sie in ein großes Stück Text. Dies gibt dem Modell ein vollständigeres Bild von jedem Spiel, wenn es in Vektoren umgewandelt wird. combined text field self.df['combined_text'] = ( self.df['name'].astype(str) + " " + self.df['desc_snippet'].astype(str) + " " + self.df['genre'].astype(str) + " " + self.df['game_details'].astype(str) + " " + self.df['game_description'].astype(str) ) Und schließlich, ist, was alles super snappy macht. dank Superlinked's , der Retriever kann Abfragen in Echtzeit bearbeiten, keine Verzögerungen, nur sofortige Ergebnisse.Das bedeutet, ob jemand nach einem bestimmten Genre jagt oder nur nach etwas Neues sucht, um zu spielen, erhalten sie schnelle und genaue Empfehlungen, ohne zu warten. in-memory execution InMemoryExecutor # Set up in-memory source and executor source = sl.InMemorySource(self.game, parser=parser) self.executor = sl.InMemoryExecutor(sources=[source], indices=[self.index]) self.app = self.executor.run() # Load data source.put([self.df]) Setzen Sie all diese Stücke zusammen, und Sie haben die — ein solides Setup für die Bereitstellung von Spielempfehlungen, die für den Benutzer wirklich Sinn machen. Es ist schnell, intelligent und persönlich. SuperlinkedSteamGamesRetriever class SuperlinkedSteamGamesRetriever(BaseRetriever): """A custom LlamaIndex retriever using Superlinked for Steam games data.""" def __init__(self, csv_file: str, top_k: int = 10): """ Initialize the retriever with a CSV file path and top_k parameter. Args: csv_file (str): Path to games_data.csv top_k (int): Number of results to return (default: 10) """ self.top_k = top_k # Load the dataset and ensure all required columns are present self.df = pd.read_csv(csv_file) print(f"Loaded dataset with {len(self.df)} games") print("DataFrame Columns:", list(self.df.columns)) required_columns = [ 'game_number', 'name', 'desc_snippet', 'game_details', 'languages', 'genre', 'game_description', 'original_price', 'discount_price' ] for col in required_columns: if col not in self.df.columns: raise ValueError(f"Missing required column: {col}") # Combine relevant columns into a single field for text similarity self.df['combined_text'] = ( self.df['name'].astype(str) + " " + self.df['desc_snippet'].astype(str) + " " + self.df['genre'].astype(str) + " " + self.df['game_details'].astype(str) + " " + self.df['game_description'].astype(str) ) self._setup_superlinked() def _setup_superlinked(self): """Set up Superlinked schema, space, index, and executor.""" # Define schema class GameSchema(sl.Schema): game_number: sl.IdField name: sl.String desc_snippet: sl.String game_details: sl.String languages: sl.String genre: sl.String game_description: sl.String original_price: sl.Float discount_price: sl.Float combined_text: sl.String # New field for combined text self.game = GameSchema() # Create text similarity space using the combined_text field self.text_space = sl.TextSimilaritySpace( text=self.game.combined_text, model="sentence-transformers/all-mpnet-base-v2" ) # Create index self.index = sl.Index([self.text_space]) # Map DataFrame columns to schema parser = sl.DataFrameParser( self.game, mapping={ self.game.game_number: "game_number", self.game.name: "name", self.game.desc_snippet: "desc_snippet", self.game.game_details: "game_details", self.game.languages: "languages", self.game.genre: "genre", self.game.game_description: "game_description", self.game.original_price: "original_price", self.game.discount_price: "discount_price", self.game.combined_text: "combined_text" } ) # Set up in-memory source and executor source = sl.InMemorySource(self.game, parser=parser) self.executor = sl.InMemoryExecutor(sources=[source], indices=[self.index]) self.app = self.executor.run() # Load data source.put([self.df]) print(f"Initialized Superlinked retriever with {len(self.df)} games") def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]: """ Retrieve top-k games based on the query string. Args: query_bundle (QueryBundle): Contains the query string Returns: List[NodeWithScore]: List of retrieved games with scores """ query_text = query_bundle.query_str # Define Superlinked query with explicit field selection query = ( sl.Query(self.index) .find(self.game) .similar(self.text_space, query_text) .select([ self.game.game_number, self.game.name, self.game.desc_snippet, self.game.game_details, self.game.languages, self.game.genre, self.game.game_description, self.game.original_price, self.game.discount_price ]) .limit(self.top_k) ) # Execute query result = self.app.query(query) df_result = sl.PandasConverter.to_pandas(result) # Convert results to NodeWithScore objects nodes_with_scores = [] for i, row in df_result.iterrows(): text = f"{row['name']}: {row['desc_snippet']}" metadata = { "game_number": row["id"], "name": row["name"], "desc_snippet": row["desc_snippet"], "game_details": row["game_details"], "languages": row["languages"], "genre": row["genre"], "game_description": row["game_description"], "original_price": row["original_price"], "discount_price": row["discount_price"] } score = 1.0 - (i / self.top_k) node = TextNode(text=text, metadata=metadata) nodes_with_scores.append(NodeWithScore(node=node, score=score)) return nodes_with_scores print("✅ SuperlinkedSteamGamesRetriever class defined successfully!") Integration Architecture Deep Dive Teil 3: Superlinked Schema Definition und Setup Beginnend mit Schema-Design, jetzt in Superlinked, geht das Schema nicht nur darum, Datentypen zu definieren, es ist mehr wie eine formale Definition zwischen unseren Daten und der zugrunde liegenden Vektorrechnungsmaschine. In unserer Das Schema ist so definiert: SuperlinkedSteamGamesRetriever class GameSchema(sl.Schema): game_number: sl.IdField name: sl.String desc_snippet: sl.String game_details: sl.String languages: sl.String genre: sl.String game_description: sl.String original_price: sl.Float discount_price: sl.Float combined_text: sl.String # New field for combined text self.game = GameSchema() Lassen Sie uns auflösen, was einige dieser Elemente tatsächlich : macht (→ ) Think of this as our primary key. It gives each game a unique identity and allows Superlinked to index and retrieve items efficiently, I mean basically it’s about how we are telling the Superlinked to segregate the unique identify of the games, and btw it’s especially important when you're dealing with thousands of records. sl.IdField game_number and Now these aren't just type hints—they enable Superlinked to optimize operations differently depending on the field. For instance, fields can be embedded and compared semantically, while fields can support numeric filtering or sorting. sl.String sl.Float sl.String sl.Float This is the of our retriever. It’s a synthetic field where we concatenate the game name, description, genre, and other relevant attributes into a single block of text. This lets us build a single using sentence-transformer embeddings: combined_text semantic anchor text similarity space self.text_space = sl.TextSimilaritySpace( text=self.game.combined_text, model="sentence-transformers/all-mpnet-base-v2" ) Weil Benutzer nicht nur nach Genre oder Namen suchen, sie beschreiben, was sie sind Wenn Sie alle wichtigen Signale in Wir können fuzzy, natürlichsprachige Abfragen besser mit den relevantesten Spielen übereinstimmen. Suche nach combined_text Teil 4: Vektorraumkonfiguration # Create text similarity space using the combined_text field self.text_space = sl.TextSimilaritySpace( text=self.game.combined_text, model="sentence-transformers/all-mpnet-base-v2" ) # Create index self.index = sl.Index([self.text_space]) Um die semantische Suche über unseren Steam-Spieldatensatz zu ermöglichen, habe ich zwei absichtliche Designentscheidungen getroffen, die Leistung, Einfachheit und Flexibilität ausgleichen. Zuerst, für das Embedded-Modell, habe ich ausgewählt Dieses Modell produziert 768-dimensionale Embeddings, die einen soliden Mittelfeld treffen: Sie sind ausdrucksstark genug, um eine reiche semantische Bedeutung zu erfassen, aber leicht genug, um schnell in der Produktion zu sein. Ich meine, es ist ein zuverlässiges Modell für allgemeine Zwecke, das bekannt ist, dass es in verschiedenen Texttypen gut funktioniert - was sehr wichtig ist, wenn Ihre Daten von kurzen Genre-Tags bis hin zu langen Spielbeschreibungen reichen. Handhaben Sie es sauber. all-mpnet-base-v2 all-mpnet-base-v2 Als nächstes, obwohl Superlinked Multi-Space-Indexierung unterstützt – wo Sie mehrere Felder oder sogar Modalitäten (wie Text + Bilder) kombinieren können. Ich hätte die hier auch, aber ich habe nicht die Informationen über das Release-Datum für die Spiele. aber nur um dies hier auszudrücken, wenn wir die Release-Datum-Informationen haben, könnte ich hier den RecencySpace anschließen, und ich kann sogar die Spiele mit dem Neben den neuesten Spiele. cool. TextSimilaritySpace RecencySpace TextSimilaritySpace Teil 5: Data Pipeline und Executor Setup # Map DataFrame columns to schema - Critical for data integrity parser = sl.DataFrameParser( self.game, mapping={ self.game.game_number: "game_number", self.game.name: "name", self.game.desc_snippet: "desc_snippet", self.game.game_details: "game_details", self.game.languages: "languages", self.game.genre: "genre", self.game.game_description: "game_description", self.game.original_price: "original_price", self.game.discount_price: "discount_price", self.game.combined_text: "combined_text" } ) # Set up in-memory source and executor source = sl.InMemorySource(self.game, parser=parser) self.executor = sl.InMemoryExecutor(sources=[source], indices=[self.index]) self.app = self.executor.run() # Load data source.put([self.df]) print(f"Initialized Superlinked retriever with {len(self.df)} games") Im Herzen unseres Abrufsystems befindet sich eine gestrahlte Pipeline, die sowohl für Klarheit als auch für Geschwindigkeit gebaut wurde. Es stellt sicher, dass jedes Feld im Datensatz korrekt eingegeben und konsequent auf unser Schema übertragen wird; im Wesentlichen als Vertrag zwischen unseren rohen CSV-Daten und der Superlinked-Indexierungsschicht. DataFrameParser Sobald die Daten strukturiert sind, füttere ich sie in eine , die ideal für Datensätze ist, die bequem in den Speicher passen. Dieser Ansatz hält alles blitzschnell, ohne Speicherüberschreitung oder Netzwerklatenz einzuführen. Dies macht Superlinked für Echtzeitanwendungen wie interaktive Empfehlungssysteme geeignet, bei denen die Geschwindigkeit die Benutzererfahrung direkt beeinflusst. InMemorySource InMemoryExecutor Teil 6: Die Retrieval-Engine def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]: """ Retrieve top-k games based on the query string. Args: query_bundle (QueryBundle): Contains the query string Returns: List[NodeWithScore]: List of retrieved games with scores """ query_text = query_bundle.query_str # Define Superlinked query with explicit field selection query = ( sl.Query(self.index) .find(self.game) .similar(self.text_space, query_text) .select([ self.game.game_number, self.game.name, self.game.desc_snippet, self.game.game_details, self.game.languages, self.game.genre, self.game.game_description, self.game.original_price, self.game.discount_price ]) .limit(self.top_k) ) # Execute query result = self.app.query(query) df_result = sl.PandasConverter.to_pandas(result) Eines der Dinge, mit denen Superlinked wirklich angenehm zu arbeiten ist, ist der Querbuilder im fließenden Stil. Wenn Sie Bibliotheken wie SQLAlchemy oder Django ORM verwendet haben, fühlt sich das Muster vertraut an. Jede Methode in der Kette fügt Klarheit anstelle von Unordnung hinzu. In unserem Fall beginnt die Abfrage mit der Auswahl des relevanten Indizes und der Definition der Ähnlichkeitssuche mithilfe der Methode, die die Cosine-Ähnlichkeit im Embedding-Raum berechnet. Dies ermöglicht es uns, semantisch enge Spiele basierend auf der natürlichen Sprachabfrage des Benutzers abzurufen. .similar() Eine andere durchdachte Designentscheidung, die ich getroffen habe, war Ich interessiere mich für das Ergebnis, anstatt etwas wie Dies mag klein klingen, aber es hält die Daten lean, reduziert die Verarbeitung überhead, und stellt sicher, dass wir nicht unnötige Nutzlast während der Post-Prozessing zu umgehen. denken Sie darüber als Präzision über die Masse, besonders wichtig, wenn Sie Daten zwischen Komponenten in einer Latenz-empfindlichen Pipeline bewegen. explicitly select the fields SELECT * Teil 7: Ergebnisverarbeitung und Node-Erstellung # Convert to LlamaIndex NodeWithScore format nodes_with_scores = [] for i, row in df_result.iterrows(): text = f"{row['name']}: {row['desc_snippet']}" metadata = { "game_number": row["id"], "name": row["name"], "desc_snippet": row["desc_snippet"], "game_details": row["game_details"], "languages": row["languages"], "genre": row["genre"], "game_description": row["game_description"], "original_price": row["original_price"], "discount_price": row["discount_price"] } # Simple ranking score based on result position score = 1.0 - (i / self.top_k) node = TextNode(text=text, metadata=metadata) nodes_with_scores.append(NodeWithScore(node=node, score=score)) return nodes_with_scores Nachdem wir die Ergebnisse von Superlinked erhalten haben, habe ich sie in ein Format umgewandelt, das gut mit LlamaIndex spielt. String durch Kombination des Namens des Spiels mit seiner kurzen Beschreibung. Dies wird der Inhalt jedes Knoten, so dass es einfacher für das Sprachmodell zu reden.Es ist eine kleine Berührung, aber es verbessert wirklich, wie relevant und verständlich die abgerufenen Daten sind, wenn an den LLM weitergeleitet. human-readable text Danach stellen wir sicher, dass aus dem Datensatz, einschließlich Dinge wie Genre, Preisgestaltung und Spieldetails - werden in den Metadaten gespeichert. Dies ist entscheidend, weil nachgelagerte Prozesse möglicherweise Ergebnisse basierend auf diesen Informationen filtern, anzeigen oder rangieren möchten. all original fields Schließlich verwende ich ein leichtes Gewicht Strategie. Anstatt sich auf rohe Ähnlichkeits-Score zu verlassen, vergeben wir Punkte basierend auf der Position des Ergebnisses in der rangierten Liste. Dies hält die Dinge einfach und konsistent. Das oberste Ergebnis hat immer die höchste Punktzahl, und der Rest folgt in absteigender Reihenfolge. Es ist nicht fantastisch, aber es gibt uns ein stabiles und interpretierbares Scoring-System, das in verschiedenen Abfragen gut funktioniert. score normalisation Zeige Zeit: Die Pipeline ausführen Jetzt, wo alle Komponenten vorhanden sind, ist es an der Zeit, unser Retrieval-Augmented Generation (RAG) System zum Leben zu erwecken. # Initialize the RAG pipeline print("Setting up complete Retrieval pipeline...") # Create response synthesizer and query engine response_synthesizer = get_response_synthesizer() query_engine = RetrieverQueryEngine( retriever=retriever, response_synthesizer=response_synthesizer ) print("✅ RAG pipeline configured successfully!") print("\n" + "="*60) print("FULL RAG PIPELINE DEMONSTRATION") print("="*60) # Test queries with full RAG responses test_queries = [ "I want to find a magic game with spells and wizards", "Recommend a fun party game for friends", "I'm looking for a strategic sci-fi game", "What's a good cooperative game for teamwork?" ] for i, query in enumerate(test_queries, 1): print(f"\nQuery {i}: '{query}'") print("-" * 50) response = query_engine.query(query) print(f"Response: {response}") print("\n" + "="*50) Diese Einstellung kombiniert unseren benutzerdefinierten semantischen Retriever mit einem LLM-fähigen Antwortgenerator. Abfragen bewegen sich reibungslos durch die Pipeline, und anstatt nur rohe Daten zu spucken, gibt es einen nachdenklichen Vorschlag, welche Art von Spiel der Benutzer tatsächlich spielen möchte, basierend auf dem, was er gefragt hat. Takeaways Nehmen Sie Custom retrievers let you bake domain rules and jargon into the system. Combining multiple text fields into one index improves query understanding. In LlamaIndex you only need to implement _retrieve for a custom backend. Superlinked InMemoryExecutor gives real time latency on moderate datasets. Schema choice matters for clean parsing and mapping. Simple position based scoring is a stable default when you want predictable ranks.\ If you want a quick chat about where mixture of encoders or multi-field retrieval fits in your pipeline, ! talk to one of our engineers Wenn Sie einen schnellen Chat darüber wollen, wo eine Mischung von Encodern oder Multi-Field-Erfassung in Ihre Pipeline passt, ! Sprechen Sie mit einem unserer Ingenieure Sprechen Sie mit einem unserer Ingenieure Sprechen Sie mit einem unserer Ingenieure Integrationsreferenzen: Superlinked Retriever-Paket auf PyPI- und LlamaIndex-Dokumente für benutzerdefinierte Retriever. Beiträge Vipul Maheshwari, Autor Filip Makraduli, Herausgeber
