Chunk ID stringlengths 5 184 | Chunk stringlengths 20 3.59k | Source stringclasses 22
values |
|---|---|---|
Retrieval augmented generation using Elasticsearch and OpenAI - Part 22 | Use Chat Completions API for retrieval augmented generation
Now we can send the question and the text to OpenAI's chat completion API.
Using a LLM model together with a retrieval model is known as retrieval augmented generation (RAG). We're using Elasticsearch to do what it does best, retrieve relevant documents. Then... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-retrieval-augmented-generation |
Retrieval augmented generation using Elasticsearch and OpenAI - Part 23 | The model will generate a response to the question, using the top kNN hit as context. Use the messages list to shape your prompt to the model. In this example, we're using the gpt-3.5-turbo model. | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-retrieval-augmented-generation |
Retrieval augmented generation using Elasticsearch and OpenAI - Part 24 | summary = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Answer the following question:"
+ question
+ "by using the following text:"
+ top_hit_summary},
]
)
... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-retrieval-augmented-generation |
Retrieval augmented generation using Elasticsearch and OpenAI - Part 25 | Here's what that code does:Uses OpenAI's model to generate a response, Sends a conversation containing a system message and a user message to the model. The system message sets the assistant's role as 'helpful assistant'. The user message contains a question as specified in the original kNN query and some input text. T... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-retrieval-augmented-generation |
Semantic search using Elasticsearch and OpenAI (Part 1) | This notebook demonstrates how to:
Index the OpenAI Wikipedia vector dataset into Elasticsearch
Embed a question with the OpenAI embeddings endpoint
Perform semantic search on the Elasticsearch index using the encoded question
Install packages and import modules
# install packages
!python3 -m pip install -qU openai p... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 2) | Connect to Elasticsearch
ℹ️ We're using an Elastic Cloud deployment of Elasticsearch for this notebook. If you don't already have an Elastic deployment, you can sign up for a free Elastic Cloud trial.
To connect to Elasticsearch, you need to create a client instance with the Cloud ID and password for your deployment.
... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 3) | # Test connection to Elasticsearch
print(client.info())
Download the dataset
In this step we download the OpenAI Wikipedia embeddings dataset, and extract the zip file.
embeddings_url = 'https://cdn.openai.com/API/examples/data/vector_database_wikipedia_articles_embedded.zip'
wget.download(embeddings_url)
with zipfil... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 4) | Read CSV file into a Pandas DataFrame
Next we use the Pandas library to read the unzipped CSV file into a DataFrame. This step makes it easier to index the data into Elasticsearch in bulk.
wikipedia_dataframe = pd.read_csv("data/vector_database_wikipedia_articles_embedded.csv") | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 5) | Create index with mapping
Now we need to create an Elasticsearch index with the necessary mappings. This will enable us to index the data into Elasticsearch.
We use the dense_vector field type for the title_vector and content_vector fields. This is a special field type that allows us to store dense vectors in Elastics... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 6) | "content_vector": {
"type": "dense_vector",
"dims": 1536,
"index": "true",
"similarity": "cosine"
},
"text": {"type": "text"},
"title": {"type": "text"},
"url": { "type": "keyword"},
"vector_id": {"type": "long"}
}
}
client.indices.create(index=... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 7) | def dataframe_to_bulk_actions(df):
for index, row in df.iterrows():
yield {
"_index": 'wikipedia_vector_index',
"_id": row['id'],
"_source": {
'url' : row["url"],
'title' : row["title"],
'text' : row["text"],
... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 8) | start = 0
end = len(wikipedia_dataframe)
batch_size = 100
for batch_start in range(start, end, batch_size):
batch_end = min(batch_start + batch_size, end)
batch_dataframe = wikipedia_dataframe.iloc[batch_start:batch_end]
actions = dataframe_to_bulk_actions(batch_dataframe)
helpers.bulk(client, actions)
... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 9) | Encode a question with OpenAI embedding model
To perform semantic search, we need to encode queries with the same embedding model used to encode the documents at index time. In this example, we need to use the text-embedding-ada-002 model.
You'll need your OpenAI API key to generate the embeddings.
# Get OpenAI API k... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 10) | Run semantic search queries
Now we're ready to run queries against our Elasticsearch index using our encoded question. We'll be doing a k-nearest neighbors search, using the Elasticsearch kNN query option.
First, we define a small function to pretty print the results.
# Function to pretty print Elasticsearch results
... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Semantic search using Elasticsearch and OpenAI (Part 11) | Next steps
Success! Now you know how to use Elasticsearch as a vector database to store embeddings, encode queries by calling the OpenAI embeddings endpoint, and run semantic search.
Play around with different queries, and if you want to try with your own data, you can experiment with different embedding models.
ℹ️ C... | https://cookbook.openai.com/examples/vector_databases/elasticsearch/elasticsearch-semantic-search |
Data preparation and analysis for chat model fine-tuning | This notebook serves as a tool to preprocess and analyze the chat dataset used for fine-tuning a chat model. It checks for format errors, provides basic statistics, and estimates token counts for fine-tuning costs. The method shown here corresponds to legacy fine-tuning for models like babbage-002 and davinci-002. For ... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Data loading | We first load the chat dataset from an example JSONL file. data_path = "data/toy_chat_fine_tuning.jsonl" # Load the dataset with open(data_path, 'r', encoding='utf-8') as f: dataset = [json.loads(line) for line in f] # Initial dataset stats print("Num examples:", len(dataset)) print("First example:") for message in dat... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Format validation | We can perform a variety of error checks to validate that each conversation in the dataset adheres to the format expected by the fine-tuning API. Errors are categorized based on their nature for easier debugging. Data Type Check: Checks whether each entry in the dataset is a dictionary (dict). Error type: data_type. Pr... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Token Counting Utilities | Lets define a few helpful utilities to be used in the rest of the notebook. encoding = tiktoken.get_encoding("cl100k_base") # not exact! # simplified from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb def num_tokens_from_messages(messages, tokens_per_message=3, tok... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Data Warnings and Token Counts | With some lightweight analysis we can identify potential issues in the dataset, like missing messages, and provide statistical insights into message and token counts. Missing System/User Messages: Counts the number of conversations missing a "system" or "user" message. Such messages are critical for defining the assist... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Warnings and tokens counts | n_missing_system = 0 n_missing_user = 0 n_messages = [] convo_lens = [] assistant_message_lens = [] for ex in dataset: messages = ex["messages"] if not any(message["role"] == "system" for message in messages): n_missing_system += 1 if not any(message["role"] == "user" for message in messages): n_missing_user += 1 n_mes... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
Cost Estimation | In this final section, we estimate the total number of tokens that will be used for fine-tuning, which allows us to approximate the cost. It is worth noting that the duration of the fine-tuning jobs will also increase with the token count. # Pricing and default n_epochs estimate MAX_TOKENS_PER_EXAMPLE = 4096 TARGET_EPO... | https://cookbook.openai.com/examples/chat_finetuning_data_prep |
How to fine-tune chat models | This notebook provides a step-by-step guide for our new gpt-3.5-turbo fine-tuning. We'll perform entity extraction using the RecipeNLG dataset, which provides various recipes and a list of extracted generic ingredients for each. This is a common dataset for named entity recognition (NER) tasks. | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Data preparation | We'll begin by preparing our data. When fine-tuning with the ChatCompletion format, each training example is a simple list of messages. For example, an entry could look like:
[{'role': 'system', 'content': 'You are a helpful recipe assistant. You are to extract the generic ingredients from each of the recipes provided... | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Upload files | You can now upload the files to our Files endpoint to be used by the fine-tuned model.
training_response = openai.File.create(
file=open(training_file_name, "rb"), purpose="fine-tune"
)
training_file_id = training_response["id"]
validation_response = openai.File.create(
file=open(validation_file_name, "rb"), ... | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Fine-tuning | Now we can create our fine-tuning job with the generated files and an optional suffix to identify the model. The response will contain an id which you can use to retrieve updates on the job.
Note: The files have to first be processed by our system, so you might get a File not ready error. In that case, simply retry a ... | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Check job status | You can make a GET request to the https://api.openai.com/v1/alpha/fine-tunes endpoint to list your alpha fine-tune jobs. In this instance you'll want to check that the ID you got from the previous step ends up as status: succeeded.
Once it is completed, you can use the result_files to sample the results from the valid... | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Inference | The last step is to use your fine-tuned model for inference. Similar to the classic FineTuning, you simply call ChatCompletions with your new fine-tuned model name filling the model parameter.
test_df = recipe_df.loc[201:300]
test_row = test_df.iloc[0]
test_messages = []
test_messages.append({"role": "system", "conten... | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Conclusion | Congratulations, you are now ready to fine-tune your own models using the ChatCompletion format! We look forward to seeing what you build | https://cookbook.openai.com/examples/how_to_finetune_chat_models |
Evaluating Abstractive Summarization (Part 1) | In this notebook we delve into the evaluation techniques for abstractive summarization tasks using a simple example. We explore traditional evaluation methods like ROUGE and BERTScore, in addition to showcasing a more novel approach using LLMs as evaluators. | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating Abstractive Summarization (Part 2) | Evaluating the quality of summaries is a time-consuming process, as it involves different quality metrics such as coherence, conciseness, readability and content. Traditional automatic evaluation metrics such as ROUGE and BERTScore and others are concrete and reliable, but they may not correlate well with the actual qu... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating Abstractive Summarization (Part 3) | In addition to these traditional metrics, we showcase a method (G-Eval) that leverages Large Language Models (LLMs) as a novel, reference-free metric for assessing abstractive summaries. In this case, we use gpt-4 to score candidate outputs. gpt-4 has effectively learned an internal model of language quality that allow... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Setup (Part 1) | For the purposes of this notebook we'll use the example summarization below. Notice that we provide two generated summaries to compare, and a reference human-written summary, which evaluation metrics like ROUGE and BERTScore require. | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Setup (Part 2) | Excerpt (excerpt):
OpenAI's mission is to ensure that artificial general intelligence (AGI) benefits all of humanity. OpenAI will build safe and beneficial AGI directly, but will also consider its mission fulfilled if its work aids others to achieve this outcome. OpenAI follows several key principles for this purpose.... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Summaries (Part 1) | Reference Summary /ref_summary (human generated) Eval Summary 1 / eval_summary_1 (system generated) Eval Summary 2 / eval_summary_2 (system generated) | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Summaries (Part 2) | OpenAI aims to ensure artificial general intelligence (AGI) is used for everyone's benefit, avoiding harmful uses or undue power concentration. It is committed to researching AGI safety, promoting such studies among the AI community. OpenAI seeks to lead in AI capabilities and cooperates with global research and policy... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using ROUGE | ROUGE, which stands for Recall-Oriented Understudy for Gisting Evaluation, primarily gauges the overlap of words between a generated output and a reference text. It's a prevalent metric for evaluating automatic summarization tasks. Among its variants, ROUGE-L offers insights into the longest contiguous match between sy... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using BERTScore | ROUGE relies on the exact presence of words in both the predicted and reference texts, failing to interpret the underlying semantics. This is where BERTScore comes in and leverages the contextual embeddings from the BERT model, aiming to evaluate the similarity between a predicted and a reference sentence in the contex... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 1) | Here we implement an example reference-free text evaluator using gpt-4, inspired by the G-Eval framework which evaluates the quality of generated text using large language models. Unlike metrics like ROUGE or BERTScore that rely on comparison to reference summaries, the gpt-4 based evaluator assesses the quality of gen... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 2) | We craft prompts for each of these criteria, taking the original document and the summary as inputs, and leveraging chain-of-thought generation and guiding the model to output a numeric score from 1-5 for each criteria. We generate scores from gpt-4 with the defined prompts, comparing them across summaries. In this dem... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 3) | Evaluation prompt template based on G-Eval
EVALUATION_PROMPT_TEMPLATE = """
You will be given one summary written for an article. Your task is to rate the summary on one metric.
Please make sure you read and understand these instructions very carefully.
Please keep this document open while reviewing, and refer to it a... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 4) | Metric 1: Relevance
RELEVANCY_SCORE_CRITERIA = """
Relevance(1-5) - selection of important content from the source. The summary should include only important information from the source document. Annotators were instructed to penalize summaries which contained redundancies and excess information.""" | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 5) | Metric 2: Coherence
COHERENCE_SCORE_CRITERIA = """
Coherence(1-5) - the collective quality of all sentences. We align this dimension with the DUC quality question of structure and coherence whereby "the summary should be well-structured and well-organized. The summary should not just be a heap of related information, ... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 6) | Metric 3: Consistency
CONSISTENCY_SCORE_CRITERIA = """
Consistency(1-5) - the factual alignment between the summary and the summarized source. A factually consistent summary contains only statements that are entailed by the source document. Annotators were also asked to penalize summaries that contained hallucinated f... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 7) | Metric 4: Fluency
FLUENCY_SCORE_CRITERIA = """
Fluency(1-3): the quality of the summary in terms of grammar, spelling, punctuation, word choice, and sentence structure.
1: Poor. The summary has many errors that make it hard to understand or sound unnatural.
2: Fair. The summary has some errors that affect the clarity ... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 8) | def get_geval_score(
criteria: str, steps: str, document: str, summary: str, metric_name: str
):
prompt = EVALUATION_PROMPT_TEMPLATE.format(
criteria=criteria,
steps=steps,
metric_name=metric_name,
document=document,
summary=summary,
) | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 9) | response = openai.ChatCompletion.create(
model="gpt-4",
messages=[{"role": "user", "content": prompt}],
temperature=0,
max_tokens=5,
top_p=1,
frequency_penalty=0,
presence_penalty=0,
) | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 10) | return response.choices[0].message.content | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 11) | evaluation_metrics = {
"Relevance": (RELEVANCY_SCORE_CRITERIA, RELEVANCY_SCORE_STEPS),
"Coherence": (COHERENCE_SCORE_CRITERIA, COHERENCE_SCORE_STEPS),
"Consistency": (CONSISTENCY_SCORE_CRITERIA, CONSISTENCY_SCORE_STEPS),
"Fluency": (FLUENCY_SCORE_CRITERIA, FLUENCY_SCORE_STEPS),
} | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 12) | summaries = {"Summary 1": eval_summary_1, "Summary 2": eval_summary_2} | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 13) | data = {"Evaluation Type": [], "Summary Type": [], "Score": []} | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 14) | for eval_type, (criteria, steps) in evaluation_metrics.items():
for summ_type, summary in summaries.items():
data["Evaluation Type"].append(eval_type)
data["Summary Type"].append(summ_type)
result = get_geval_score(criteria, steps, excerpt, summary, eval_type)
score_num = int(result.... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 15) | pivot_df = pd.DataFrame(data, index=None).pivot(
index="Evaluation Type", columns="Summary Type", values="Score"
) | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Evaluating using GPT-4 (Part 16) | styled_pivot_df = pivot_df.style.apply(highlight_max, axis=1)
display(styled_pivot_df) | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Limitations | Note that LLM-based metrics could have a bias towards preferring LLM-generated texts over human-written texts. Additionally LLM based metrics are sensitive to system messages/prompts. We recommend experimenting with other techniques that can help improve performance and/or get consistent scores, striking the right bala... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Conclusion | Conclusion
Evaluating abstractive summarization remains an open area for further improvement. Traditional metrics like ROUGE, BLEU, and BERTScore provide useful automatic evaluation but have limitations in capturing semantic similarity and nuanced aspects of summarization quality. Moreover, they require reference outpu... | https://cookbook.openai.com/examples/evaluation/how_to_eval_abstractive_summarization |
Function calling for nearby places: Leveraging the Google Places API and customer profiles | This notebook is centered around the integration of the Google Places API and custom user profiles to enhance location-based searches. Our approach involves using the Google Places API in combination with user preferences, aiming to make location discovery more personal and relevant. Please note that while we focus on ... | https://cookbook.openai.com/examples/function_calling_finding_nearby_places |
Customer profile: This mock profile captures individual preferences for types of places (e.g., restaurants, parks, museums), budget, preferred ratings, and other specific requirements. | We'll explore the application of three main components:
Customer profile: This mock profile captures individual preferences for types of places (e.g., restaurants, parks, museums), budget, preferred ratings, and other specific requirements.
Google Places API: This API provides real-time data about nearby places. It f... | https://cookbook.openai.com/examples/function_calling_finding_nearby_places |
Profile-based recommendations: Learn how to create a user profile and make place recommendations based on individual preferences. | This notebook introduces two primary use cases:
Profile-based recommendations: Learn how to create a user profile and make place recommendations based on individual preferences.
API integration with function calling: Understand how to integrate and call Google Places API effectively to source real-time data of variou... | https://cookbook.openai.com/examples/function_calling_finding_nearby_places |
Setup Google Places API | To use the Google Places API, you'll need two things:
Google Account: If you don't already have one, you will need to create a Google account.
Google Places API Key: The API key is a unique identifier that is used to authenticate requests associated with your project for usage and billing purposes. You can get your A... | https://cookbook.openai.com/examples/function_calling_finding_nearby_places |
In this code snippet, we are defining a function fetch_customer_profile that accepts a user_id and returns a mock user profile. | In this code snippet, we are defining a function fetch_customer_profile that accepts a user_id and returns a mock user profile.
This function simulates an API call that fetches user data from a database. For this demo, we're using hard-coded data. The user profile contains various details such as the user's location (... | https://cookbook.openai.com/examples/function_calling_finding_nearby_places |
Using Qdrant for Embeddings Search | This notebook takes you through a simple flow to download some data, embed it, and then index and search it using a selection of vector databases. This is a common requirement for customers who want to store and search our embeddings with their own data in a secure environment to support production use cases such as ch... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
What is a Vector Database | A vector database is a database made to store, manage and search embedding vectors. The use of embeddings to encode unstructured data (text, audio, video and more) as vectors for consumption by machine-learning models has exploded in recent years, due to the increasing effectiveness of AI in solving use cases involving... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Why use a Vector Database | Vector databases enable enterprises to take many of the embeddings use cases we've shared in this repo (question and answering, chatbot and recommendation services, for example), and make use of them in a secure, scalable environment. Many of our customers make embeddings solve their problems at small scale but perform... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Demo Flow | The demo flow is:
Setup: Import packages and set any required variables
Load data: Load a dataset and embed it using OpenAI embeddings
Qdrant
Setup: Here we'll set up the Python client for Qdrant. For more details go here
Index Data: We'll create a collection with vectors for titles and content
Search Data: We'll run ... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Setup | Import the required libraries and set the embedding model that we'd like to use.
# We'll need to install Qdrant client
!pip install qdrant-client
#Install wget to pull zip file
!pip install wget
import openai
from typing:... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Load data | In this section we'll load embedded data that we've prepared previous to this session.
embeddings_url = 'https://cdn.openai.com/API/examples/data/vector_database_wikipedia_articles_embedded.zip'
# The file is ~700 MB so this will take some time
wget.download(embeddings_url)... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Qdrant | Qdrant. is a high-performant vector search database written in Rust. It offers both on-premise and cloud version, but for the purposes of that example we're going to use the local deployment mode.
Setting everything up will require:
Spinning up a local instance of Qdrant
Configuring the collection and storing the dat... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Index data | Qdrant stores data in collections where each object is described by at least one vector and may contain an additional metadata called payload. Our collection will be called Articles and each object will be described by both title and content vectors.
We'll be using an official qdrant-client package that has all the ut... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Search Data | Once the data is put into Qdrant we will start querying the collection for the closest vectors. We may provide an additional parameter vector_name to switch from title to content based search.
def query_qdrant(query, collection_name, vector_name='title', top_k=20):
# Creates embedding vector from user query
e... | https://cookbook.openai.com/examples/vector_databases/qdrant/using_qdrant_for_embeddings_search |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.