Išmanusis, greitesnis būdas ieškoti „Steam“ bibliotekos Jūs žinote jausmą. Jūs ieškote žaidimo, kuris yra strateginis, kooperatyvas, galbūt su mokslinės fantastikos tema. Jūs gaunate pavadinimų sieną, kuri atitinka tokį tipą. Ką jūs norėjote, buvo trumpas sąrašas, kuris tikrai užfiksuoja jūsų žodžių atmosferą. Šiame vadove mes parodome, kaip sukurti tiksliai tai, susieti Superlinked su LlamaIndex. Rezultatas yra pritaikytas "Steam" žaidimo gavėjas, kuris supranta žanrą ir aprašymą bei žymes ir teikia atsakymus per milisekundes. * į Norite tai pamatyti savo duomenyse su realiomis užklausomis ir vėlavimo skaičiais? . Get in touch Prisijunkite prie Prisijunkite prie Žymės: dr Custom retrievers suteikia jums kontroliuoti domeno kontekstą, metaduomenis ir reitingavimo logiką.Jie pranoksta bendrą panašumo paiešką, kai užklausos yra netvarkingos ar sunkios. "Superlinked" sujungia kelis teksto laukus į vieną semantinę erdvę ir paleidžia užklausas atmintyje, kad gautų greitų rezultatų. LlamaIndex suteikia švarią retrieverio sąsają ir tiesiogiai prisijungia prie užklausų variklių ir atsakymų sintezės. LlamaIndex yra oficiali Superlinked retriever integracija, kurią galite importuoti ir naudoti. Oficialus Superlinked retriever LlamaIndex Superlinked integruojasi su LlamaIndex per oficialią išvardyti LlamaHub, todėl galite pridėti Superlinked į savo esamą LlamaIndex krūva su paprastu diegimo ir Tada įdėkite jį į a Sužinokite daugiau apie Klasės ir konstruktoriaus parametrai yra dokumentuojami LlamaIndex API nuorodoje. SuperlinkedRetriever from llama_index.retrievers.superlinked import SuperlinkedRetriever RetrieverQueryEngine . Oficialus integracijos puslapis . Oficialus integracijos puslapis Oficialus integracijos puslapis 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") Ar norėtumėte jį sukurti rankomis ar pritaikyti logiką toliau? Why Superlinked + LlamaIndex? Kodėl Superlinked + LlamaIndex? Tikslas yra paprastas: paimkite „Superlinked“ stipriąsias puses kelių laukų paieškai ir supakuokite jas taip, kad kūrėjai galėtų priimti ir išplėsti realias RAG sistemas. „Superlinked“ padeda apibrėžti išraiškingas vektorines erdves ir užklausas, kurios sujungia laukus, tokius kaip vardas, aprašymas ir žanras, į vieną semantinį vaizdą. „LlamaIndex“ suteikia paieškos abstrakciją, užklausų variklius ir atsakymų sintezę, kuri įtraukia programas ir agentus su minimaliu klijais. Taip pat galite sekti į naudojant tuos pačius pastatų blokus iš Superlinked Notebooks. „Google“ Kolabė „Google“ Kolabė Kolabė Kodėl Custom Retrievers Svarbu Tinkamai pritaikytas jūsų domenui – bendrieji retrieveriai puikiai tinka bendram naudojimui, tačiau jie linkę praleisti subtilius dalykus. Pagalvokite apie žargoną, santrumpa ar domeno specifinę frazę, jie paprastai nepatenka, nebent jūsų retrieveris žino, ko ieškoti. Veikia už teksto ribų – dauguma realaus pasaulio duomenų yra ne tik paprastas tekstas. Dažnai turėsite ir metaduomenis bei žymes. Pavyzdžiui, žaidimo rekomendacijų sistemoje mums rūpi ne tik žaidimo aprašymas. Mes taip pat norime atsižvelgti į žanrus, žymes, naudotojų reitingus ir dar daugiau. Pagalvokite apie šią logiką: kažkas, ieškantis „strategijos bendradarbiavimo žaidimo su mokslinės fantastikos elementais“, nepasieks tik teksto atitikimo. Tinkamo filtravimo ir reitingavimo logika - Kartais norite taikyti savo taisykles, kaip viskas yra įvertinta ar filtruojama. Galbūt norite teikti pirmenybę naujesniam turiniui arba nubausti rezultatus, kurie neatitinka tam tikrų kokybės slenksčių. Efektyvumo padidėjimas – būkime realūs: bendrojo tikslo sprendimai yra sukurti taip, kad dirbtų „gerai“ visiems, o ne jums.Jei žinote savo duomenis ir prieigos modelius, galite tiksliai pritaikyti retrieverį, kad jis veiktų greičiau, geriau reitinguotų ir sumažintų nereikalingą triukšmą rezultatuose. Įgyvendinimo sutrikimas 1 dalis: Pagrindinės priklausomybės ir importas 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 Importo struktūra atskleidžia mūsų hibridinį požiūrį: LlamaIndex Core: suteikia surinkimo abstrakcijos sluoksnį Superlinked Framework: tvarko vektorių skaičiavimą ir semantinę paiešką Pandas: valdo duomenų perdirbimą ir manipuliavimą 2 dalis: Suprasti LlamaIndex Custom Retrievers Prieš pasinerdami į mūsų „Superlinked“ įgyvendinimą, labai svarbu suprasti, kaip veikia „LlamaIndex“ pritaikyto retrieverio architektūra ir kodėl ji yra tokia galinga kuriant domeno specifines RAG programas. BaseRetriever abstrakcija LlamaIndex pateikia abstraktų Šio dizaino grožis slypi jo paprastume – bet kuriam pritaikytam retrieverį reikia įgyvendinti tik vieną pagrindinį metodą: 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 Priežastis čia yra "LlamaIndex" atkūrimo protokolo buvimas. Kadangi šis "atkūrimo protokolas" leidžia lengvai prijungti skirtingus galinius galus ar strategijas, nereikalaujant paliesti likusios jūsų sistemos dalies. 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. Kodėl tai svarbu? Ši abstrakcija yra švari ir Tai reiškia, kad jūs galite: Galingas Kombinuokite kelias strategijas – jei reikia, naudokite tankią vektoriaus paiešką ir raktinių žodžių filtravimą kartu. Lengvai paleiskite A / B testus – palyginkite skirtingus paieškos programėles, kad pamatytumėte, kas suteikia geresnių rezultatų jūsų vartotojams. Prijunkite bet kokį agentą ar įrankį - Nesvarbu, ar kuriate pokalbių robotą, paieškos vartotojo sąsają, ar pilną agentų sistemą, ši retrieverio sąsaja yra lengva. Pagalvokite apie atkūrimo protokolą kaip API sutartį tarp jūsų „atkūrimo smegenų“ ir visko kito. Plugging Superlinked į LlamaIndex Gerai, todėl ir klasė iš esmės yra mūsų "go-to" įrankis, skirtas pateikti protingas, semantines žaidimo rekomendacijas. mes pradėsime greitai pažvelgti į tai, kaip ji yra surinkta, o vėliau pasinerti giliau į kiekvieną dalį, kad iš tikrųjų pamatytume, kas daro šį dalyką. SuperlinkedSteamGamesRetriever Pirmiausia viršuje yra , pagalvokite apie tai kaip apie pamatą. Tai, kas išlaiko viską organizuotą ir patikimą. Pateikiame tokias svarbias detales kaip , , ir Tai išlaiko visą žaidimo informaciją švarią ir nuoseklią, ir ji prisijungia tiesiai į "Superlinked" vamzdyną, kad viskas tekėtų sklandžiai. 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() Kitas aukščiau yra Štai kur vyksta semantinės paieškos magija. modelis paversti žaidimo informacijos krūvą (pavyzdžiui, pavadinimą, aprašymą, žanrą ir kt.) į tankius vektoriaus atstovavimus. Iš esmės, jis sušvelnina visą tą tekstą kartu į kažką modelis gali suprasti. Taigi, jei kas nors ieško kažko panašaus į „atviro pasaulio nuotykius“, jis gali rasti žaidimus, kurie iš tikrųjų atitinka tą atmosferą, o ne tik tuos, kurie turi tuos tikslius žodžius. text similarity space sentence-transformers/all-mpnet-base-v2 reiškia self.text_space = sl.TextSimilaritySpace( text=self.game.combined_text, model="sentence-transformers/all-mpnet-base-v2" ) Tų Tai užima skirtingą informaciją (pvz., žaidimo pavadinimą, aprašymą, žanrą ir dar daugiau) ir susmulkina juos į vieną didelį teksto gabalėlį.Tai suteikia modeliui išsamesnį vaizdą apie kiekvieną žaidimą, kai jis paverčiamas į vektorius. 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) ) Ir pagaliau, yra tai, kas daro viską super snappy. dėka Superlinked , retrieveris gali tvarkyti užklausas realiu laiku, jokių vėlavimų, tik momentinius rezultatus.Tai reiškia, kad ar kas nors medžioja tam tikrą žanrą, ar tiesiog ieško kažko naujo žaisti, jie gauna greitas ir tikslias rekomendacijas, nelaukdami. 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]) Įdėkite visus šiuos gabaliukus kartu, ir jūs turite — tvirtas nustatymas, skirtas pristatyti žaidimų rekomendacijas, kurios iš tikrųjų yra prasmingos vartotojui. Tai greita, protinga ir asmeninė. Štai kaip visas dalykas atrodo veiksme... 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 3 dalis: Superlinked schema apibrėžimas ir nustatymas Dabar yra laikas, kai mes einame šiek tiek giliai pasinerti į tam tikrą dalyką. Pradedant nuo schemos dizaino, Dabar "Superlinked", schema yra ne tik apie duomenų tipų apibrėžimą, bet ir daugiau kaip formali apibrėžtis tarp mūsų duomenų ir pagrindinės vektoriaus skaičiavimo variklio. Mūsų schema apibrėžiama taip: 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() Išsiaiškinkime, kas iš tikrųjų yra kai kurie iš šių elementų : Daro (→ ) 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" ) Kadangi vartotojai ne tik ieško pagal žanrą ar vardą, jie apibūdina, kas jie yra Įtraukiant visus svarbius signalus į , mes galime geriau suderinti neryškias, natūralios kalbos užklausas su aktualiausiais žaidimais. Ieškoti combined_text 4 dalis: Vektorinės erdvės konfigūracija # 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]) Siekiant pagerinti semantinę paiešką per mūsų "Steam" žaidimų duomenų rinkinį, aš padariau du sąmoningus dizaino pasirinkimus, kurie subalansuoja našumą, paprastumą ir lankstumą. Pirmiausia, dėl įterpimo modelio, aš pasirinko iš Sentence Transformers bibliotekos. Šis modelis gamina 768-dimensinius įterpimus, kurie pasiekia tvirtą vidurį: jie yra pakankamai išraiškingi, kad užfiksuotų turtingą semantinę reikšmę, tačiau pakankamai lengvi, kad būtų greiti gamyboje. Aš turiu omenyje, kad tai yra patikimas bendrojo tikslo modelis, žinomas dėl to, kad gerai veikia įvairiuose teksto tipuose - o tai labai svarbu, kai jūsų duomenys svyruoja nuo trumpų žanro žymenų iki ilgų formų žaidimų aprašymų. Su juo tvarkykite švariai. all-mpnet-base-v2 all-mpnet-base-v2 Toliau, nors „Superlinked“ palaiko daugiasluoksnį indeksavimą – kur galite sujungti kelis laukus ar netgi modalumus (pavyzdžiui, tekstą + vaizdus). Būčiau įtraukęs į Taip pat čia, bet aš neturiu informacijos apie žaidimų išleidimo datą. bet tiesiog tai išdėstyti čia, jei mes turime išleidimo datą informaciją, aš galėčiau įjungti RecencySpace čia, ir aš netgi galiu rūšiuoti žaidimus su Kartu su naujausiais žaidimais. „Šaunuoliai. TextSimilaritySpace RecencySpace TextSimilaritySpace 5 dalis: Duomenų vamzdynas ir vykdytojo nustatymas # 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") Mūsų paieškos sistemos širdyje yra supaprastintas vamzdynas, sukurtas tiek aiškumui, tiek greičiui. Jis užtikrina, kad kiekvienas duomenų rinkinio laukas būtų teisingai įvestas ir nuosekliai susietas su mūsų schema; iš esmės jis veikia kaip sutartis tarp mūsų žaliųjų CSV duomenų ir superlinked indeksavimo sluoksnio. DataFrameParser Kai duomenys yra struktūrizuoti, aš juos maitinu į , kuris idealiai tinka duomenų rinkiniams, kurie patogiai tinka atmintyje. Šis metodas išlaiko viską žaibo greičiu, neįvedant saugojimo viršvalandžių ar tinklo vėlavimo. Tai daro „Superlinked“ tinkamą realaus laiko programoms, pvz., interaktyvioms rekomendacijų sistemoms, kuriose greitis tiesiogiai veikia naudotojo patirtį. InMemorySource InMemoryExecutor 6 dalis: atkūrimo variklis 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) Vienas iš dalykų, dėl kurių Superlinked yra tikrai malonu dirbti, yra jo sklandus užklausų kūrėjas. Jei naudojate tokias bibliotekas kaip SQLAlchemy ar Django ORM, modelis bus pažįstamas. Kiekvienas metodas grandinėje prideda aiškumo, o ne painiavos. Mūsų atveju užklausa prasideda pasirinkus atitinkamą indeksą ir apibrėžiant panašumo paiešką naudojant metodas, kuris apskaičiuoja cosine panašumą įterpimo erdvėje. Tai leidžia mums gauti semantiškai artimus žaidimus, pagrįstus vartotojo natūralios kalbos užklausomis. .similar() Kitas apgalvotas dizaino sprendimas, kurį aš padariau, buvo Man rūpi rezultatas, o ne daryti kažką panašaus Tai gali atrodyti nereikšminga, tačiau tai išlaiko duomenų slėgį, sumažina apdorojimo viršvalandžius ir užtikrina, kad po apdorojimo nebūtų perduodama nereikalinga naudingumo apkrova. explicitly select the fields SELECT * 7 dalis: Rezultatų apdorojimas ir mazgų kūrimas # 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 Dabar, kai mes gauname rezultatus iš Superlinked, aš juos pavertė į formatą, kuris puikiai veikia su LlamaIndex. Tai tampa kiekvieno mazgo turiniu, todėl kalbų modeliui lengviau mąstyti. Tai mažas palietimas, bet tai tikrai pagerina, kaip svarbūs ir suprantami surinkti duomenys, kai perduodami LLM. human-readable text Tada įsitikinkite, kad iš duomenų rinkinio, įskaitant tokius dalykus kaip žanras, kainos ir žaidimo detalės, išsaugomi metaduomenyse.Tai labai svarbu, nes tolesni procesai gali norėti filtruoti, rodyti ar reitinguoti rezultatus remiantis šia informacija.Nenoriu prarasti jokio naudingo konteksto, kai pradėsime dirbti su surinktais mazgais. all original fields Galiausiai taikome lengvą svorį strategiją. Užuot pasikliauję žaliaviniais panašumo balai, mes priskiriame balus pagal rezultato padėtį reitinguojamame sąraše. Tai išlaiko dalykus paprastus ir nuoseklius. Aukščiausias rezultatas visada turi didžiausią balą, o likusi dalis seka mažėjančia tvarka. Tai nėra fantazija, bet tai suteikia mums stabilią ir aiškinamą balų sistemą, kuri gerai veikia įvairiose užklausose. score normalisation Rodyti laiką: Naudojant vamzdyną Dabar, kai visi komponentai yra, atėjo laikas atnešti mūsų Retrieval-Augmented Generation (RAG) sistemą į gyvenimą. # 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) Šis nustatymas sujungia mūsų pritaikytą semantinį retrieverį su LLM varomu atsakymo generatoriumi. užklausos sklandžiai juda per dujotiekį, o vietoj to, kad tiesiog išplautų žaliuosius duomenis, jis grąžina apgalvotą pasiūlymą, kokio tipo žaidimą vartotojas iš tikrųjų norėtų žaisti, remdamasis tuo, ko jie paprašė. Takeaways Ėmė 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 Jei norite greitai kalbėtis apie tai, kur kodų mišinys ar daugialypė paieška tinka jūsų vamzdynui, ! Pasikalbėkite su vienu iš mūsų inžinierių Pasikalbėkite su vienu iš mūsų inžinierių Pasikalbėkite su vienu iš mūsų inžinierių Integracijos nuorodos: Superlinked retriever paketas ant PyPI ir LlamaIndex dokumentų pritaikytoms retrieverėms. Prisidėjėjai Vipul Maheshwari, autorius Filip Makraduli, redaktorius
