| Integrate these ✅ | +Not these ❌ | +
|---|---|
+
|
+
+
|
+
+
+
+Option 1: langchain-cli (recommended)
+ +In this guide, we will be using the `langchain-cli` to create a new integration package +from a template, which can be edited to implement your LangChain components. + +### **Prerequisites** + +- [GitHub](https://github.com) account +- [PyPi](https://pypi.org/) account + +### Boostrapping a new Python package with langchain-cli + +First, install `langchain-cli` and `poetry`: + +```bash +pip install langchain-cli poetry +``` + +Next, come up with a name for your package. For this guide, we'll use `langchain-parrot-link`. +You can confirm that the name is available on PyPi by searching for it on the [PyPi website](https://pypi.org/). + +Next, create your new Python package with `langchain-cli`, and navigate into the new directory with `cd`: + +```bash +langchain-cli integration new + +> The name of the integration to create (e.g. `my-integration`): parrot-link +> Name of integration in PascalCase [ParrotLink]: + +cd parrot-link +``` + +Next, let's add any dependencies we need + +```bash +poetry add my-integration-sdk +``` + +We can also add some `typing` or `test` dependencies in a separate poetry dependency group. + +``` +poetry add --group typing my-typing-dep +poetry add --group test my-test-dep +``` + +And finally, have poetry set up a virtual environment with your dependencies, as well +as your integration package: + +```bash +poetry install --with lint,typing,test,test_integration +``` + +You now have a new Python package with a template for LangChain components! This +template comes with files for each integration type, and you're welcome to duplicate or +delete any of these files as needed (including the associated test files). + +To create any individual files from the [template], you can run e.g.: + +```bash +langchain-cli integration new \ + --name parrot-link \ + --name-class ParrotLink \ + --src integration_template/chat_models.py \ + --dst langchain_parrot_link/chat_models_2.py +``` + +
+ 
+
+Note: Replace `` with the latest version of `langchain-tests` below.
+
+```bash
+poetry add --group test pytest pytest-socket pytest-asyncio langchain-tests==
+```
+
+And finally, have poetry set up a virtual environment with your dependencies, as well
+as your integration package:
+
+```bash
+poetry install --with test
+```
+
+You're now ready to start writing your integration package!
+
+### Writing your integration
+
+Let's say you're building a simple integration package that provides a `ChatParrotLink`
+chat model integration for LangChain. Here's a simple example of what your project
+structure might look like:
+
+```plaintext
+langchain-parrot-link/
+├── langchain_parrot_link/
+│ ├── __init__.py
+│ └── chat_models.py
+├── tests/
+│ ├── __init__.py
+│ └── test_chat_models.py
+├── pyproject.toml
+└── README.md
+```
+
+All of these files should already exist from step 1, except for
+`chat_models.py` and `test_chat_models.py`! We will implement `test_chat_models.py`
+later, following the [standard tests](../standard_tests) guide.
+
+For `chat_models.py`, simply paste the contents of the chat model implementation
+[above](#implementing-langchain-components).
+
+
+
+### Push your package to a public Github repository
+
+This is only required if you want to publish your integration in the LangChain documentation.
+
+1. Create a new repository on GitHub.
+2. Push your code to the repository.
+3. Confirm that your repository is viewable by the public (e.g. in a private browsing window, where you're not logged into Github).
+
+## Implementing LangChain components
+
+LangChain components are subclasses of base classes in [langchain-core](/docs/concepts/architecture/#langchain-core).
+Examples include [chat models](/docs/concepts/chat_models/),
+[vector stores](/docs/concepts/vectorstores/), [tools](/docs/concepts/tools/),
+[embedding models](/docs/concepts/embedding_models/) and [retrievers](/docs/concepts/retrievers/).
+
+Your integration package will typically implement a subclass of at least one of these
+components. Expand the tabs below to see details on each.
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import CodeBlock from '@theme/CodeBlock';
+
+Option 2: Poetry (manual)
+ +In this guide, we will be using [Poetry](https://python-poetry.org/) for +dependency management and packaging, and you're welcome to use any other tools you prefer. + +### **Prerequisites** + +- [GitHub](https://github.com) account +- [PyPi](https://pypi.org/) account + +### Boostrapping a new Python package with Poetry + +First, install Poetry: + +```bash +pip install poetry +``` + +Next, come up with a name for your package. For this guide, we'll use `langchain-parrot-link`. +You can confirm that the name is available on PyPi by searching for it on the [PyPi website](https://pypi.org/). + +Next, create your new Python package with Poetry, and navigate into the new directory with `cd`: + +```bash +poetry new langchain-parrot-link +cd langchain-parrot-link +``` + +Add main dependencies using Poetry, which will add them to your `pyproject.toml` file: + +```bash +poetry add langchain-core +``` + +We will also add some `test` dependencies in a separate poetry dependency group. If +you are not using Poetry, we recommend adding these in a way that won't package them +with your published package, or just installing them separately when you run tests. + +`langchain-tests` will provide the [standard tests](../standard_tests) we will use later. +We recommended pinning these to the latest version:
+
+Note: Replace `
+
+ {
+ ChatModelSource.replaceAll('__ModuleName__', 'ParrotLink')
+ .replaceAll('__package_name__', 'langchain-parrot-link')
+ .replaceAll('__MODULE_NAME__', 'PARROT_LINK')
+ .replaceAll('__module_name__', 'langchain_parrot_link')
+ }
+
+
+
+
+ Example chat model code
+ +import ChatModelSource from '../../../../src/theme/integration_template/integration_template/chat_models.py'; + +
+
+ {
+ VectorstoreSource.replaceAll('__ModuleName__', 'ParrotLink')
+ .replaceAll('__package_name__', 'langchain-parrot-link')
+ .replaceAll('__MODULE_NAME__', 'PARROT_LINK')
+ .replaceAll('__module_name__', 'langchain_parrot_link')
+ }
+
+
+
+
+ Example vector store code
+ +import VectorstoreSource from '../../../../src/theme/integration_template/integration_template/vectorstores.py'; + +
+
+ {
+ EmbeddingsSource.replaceAll('__ModuleName__', 'ParrotLink')
+ .replaceAll('__package_name__', 'langchain-parrot-link')
+ .replaceAll('__MODULE_NAME__', 'PARROT_LINK')
+ .replaceAll('__module_name__', 'langchain_parrot_link')
+ }
+
+
+
+
+ Example embeddings code
+ +import EmbeddingsSource from '/src/theme/integration_template/integration_template/embeddings.py'; + +
+
+ {
+ ToolSource.replaceAll('__ModuleName__', 'ParrotLink')
+ .replaceAll('__package_name__', 'langchain-parrot-link')
+ .replaceAll('__MODULE_NAME__', 'PARROT_LINK')
+ .replaceAll('__module_name__', 'langchain_parrot_link')
+ }
+
+
+
+
+ Example tool code
+ +import ToolSource from '/src/theme/integration_template/integration_template/tools.py'; + +
+
+ {
+ RetrieverSource.replaceAll('__ModuleName__', 'ParrotLink')
+ .replaceAll('__package_name__', 'langchain-parrot-link')
+ .replaceAll('__MODULE_NAME__', 'PARROT_LINK')
+ .replaceAll('__module_name__', 'langchain_parrot_link')
+ }
+
+
+
+
+ Example retriever code
+ +import RetrieverSource from '/src/theme/integration_template/integration_template/retrievers.py'; + +
+
+
+```bash
+poetry config pypi-token.pypi How to create a PyPi Token
+ +1. Go to the [PyPi website](https://pypi.org/) and create an account. +2. Verify your email address by clicking the link that PyPi emails to you. +3. Go to your account settings and click "Generate Recovery Codes" to enable 2FA. To generate an API token, you **must** have 2FA enabled currently. +4. Go to your account settings and [generate a new API token](https://pypi.org/manage/account/token/). + +
+
+:::note
+
+Because added tests in new versions of `langchain-tests` can break your CI/CD pipelines, we recommend pinning the
+version of `langchain-tests` to avoid unexpected changes.
+
+:::
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+
+
+### Populating the Vector store
+
+This section shows how to populate a variety of vector stores with the sample data.
+
+For help on choosing one of the vector stores below, or to add support for your
+vector store, consult the documentation about
+[Adapters and Supported Stores](https://datastax.github.io/graph-rag/guide/adapters/).
+
+Toggle for Details
+
+ 1. Ensure you have Python 3.10+ installed
+
+ 1. Install the following package that provides sample data.
+ ```bash
+ pip install -qU graph_rag_example_helpers
+ ```
+
+ 1. Download the test documents:
+ ```python
+ from graph_rag_example_helpers.datasets.animals import fetch_documents
+ animals = fetch_documents()
+ ```
+
+ 1.
+
+ Install the `langchain-graph-retriever` package with the `astra` extra:
+
+ ```bash
+ pip install "langchain-graph-retriever[astra]"
+ ```
+
+ Then create a vector store and load the test documents:
+
+ ```python
+ from langchain_astradb import AstraDBVectorStore
+
+ vector_store = AstraDBVectorStore.from_documents(
+ documents=animals,
+ embedding=embeddings,
+ collection_name="animals",
+ api_endpoint=ASTRA_DB_API_ENDPOINT,
+ token=ASTRA_DB_APPLICATION_TOKEN,
+ )
+ ```
+ For the `ASTRA_DB_API_ENDPOINT` and `ASTRA_DB_APPLICATION_TOKEN` credentials,
+ consult the [AstraDB Vector Store Guide](/docs/integrations/vectorstores/astradb).
+
+ :::note
+ For faster initial testing, consider using the **InMemory** Vector Store.
+ :::
+
+
+ Install the `langchain-graph-retriever` package with the `cassandra` extra:
+
+ ```bash
+ pip install "langchain-graph-retriever[cassandra]"
+ ```
+
+ Then create a vector store and load the test documents:
+
+ ```python
+ from langchain_community.vectorstores.cassandra import Cassandra
+ from langchain_graph_retriever.transformers import ShreddingTransformer
+
+ vector_store = Cassandra.from_documents(
+ documents=list(ShreddingTransformer().transform_documents(animals)),
+ embedding=embeddings,
+ table_name="animals",
+ )
+ ```
+
+ For help creating a Cassandra connection, consult the
+ [Apache Cassandra Vector Store Guide](/docs/integrations/vectorstores/cassandra#connection-parameters)
+
+ :::note
+ Apache Cassandra doesn't support searching in nested metadata. Because of this
+ it is necessary to use the [`ShreddingTransformer`](https://datastax.github.io/graph-rag/reference/langchain_graph_retriever/transformers/#langchain_graph_retriever.transformers.shredding.ShreddingTransformer)
+ when inserting documents.
+ :::
+
+
+ Install the `langchain-graph-retriever` package with the `opensearch` extra:
+
+ ```bash
+ pip install "langchain-graph-retriever[opensearch]"
+ ```
+
+ Then create a vector store and load the test documents:
+
+ ```python
+ from langchain_community.vectorstores import OpenSearchVectorSearch
+
+ vector_store = OpenSearchVectorSearch.from_documents(
+ documents=animals,
+ embedding=embeddings,
+ engine="faiss",
+ index_name="animals",
+ opensearch_url=OPEN_SEARCH_URL,
+ bulk_size=500,
+ )
+ ```
+
+ For help creating an OpenSearch connection, consult the
+ [OpenSearch Vector Store Guide](/docs/integrations/vectorstores/opensearch).
+
+
+ Install the `langchain-graph-retriever` package with the `chroma` extra:
+
+ ```bash
+ pip install "langchain-graph-retriever[chroma]"
+ ```
+
+ Then create a vector store and load the test documents:
+
+ ```python
+ from langchain_chroma.vectorstores import Chroma
+ from langchain_graph_retriever.transformers import ShreddingTransformer
+
+ vector_store = Chroma.from_documents(
+ documents=list(ShreddingTransformer().transform_documents(animals)),
+ embedding=embeddings,
+ collection_name="animals",
+ )
+ ```
+
+ For help creating an Chroma connection, consult the
+ [Chroma Vector Store Guide](/docs/integrations/vectorstores/chroma).
+
+ :::note
+ Chroma doesn't support searching in nested metadata. Because of this
+ it is necessary to use the [`ShreddingTransformer`](https://datastax.github.io/graph-rag/reference/langchain_graph_retriever/transformers/#langchain_graph_retriever.transformers.shredding.ShreddingTransformer)
+ when inserting documents.
+ :::
+
+
+ Install the `langchain-graph-retriever` package:
+
+ ```bash
+ pip install "langchain-graph-retriever"
+ ```
+
+ Then create a vector store and load the test documents:
+
+ ```python
+ from langchain_core.vectorstores import InMemoryVectorStore
+
+ vector_store = InMemoryVectorStore.from_documents(
+ documents=animals,
+ embedding=embeddings,
+ )
+ ```
+
+ :::tip
+ Using the `InMemoryVectorStore` is the fastest way to get started with Graph RAG
+ but it isn't recommended for production use. Instead it is recommended to use
+ **AstraDB** or **OpenSearch**.
+ :::
+
+
+
diff --git a/openai-cookbook_md_files/vector_databases/supabase/semantic-search.mdx b/openai-cookbook_md_files/vector_databases/supabase/semantic-search.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..77bb61f23d0a82bf11cb7d4075c516e5ed17c102
--- /dev/null
+++ b/openai-cookbook_md_files/vector_databases/supabase/semantic-search.mdx
@@ -0,0 +1,276 @@
+# Semantic search using Supabase Vector
+
+The purpose of this guide is to demonstrate how to store OpenAI embeddings in [Supabase Vector](https://supabase.com/docs/guides/ai) (Postgres + pgvector) for the purposes of semantic search.
+
+[Supabase](https://supabase.com/docs) is an open-source Firebase alternative built on top of [Postgres](https://en.wikipedia.org/wiki/PostgreSQL), a production-grade SQL database. Since Supabase Vector is built on [pgvector](https://github.com/pgvector/pgvector), you can store your embeddings within the same database that holds the rest of your application data. When combined with pgvector's indexing algorithms, vector search remains [fast at large scales](https://supabase.com/blog/increase-performance-pgvector-hnsw).
+
+Supabase adds an ecosystem of services and tools to make app development as quick as possible (such as an [auto-generated REST API](https://postgrest.org/)). We'll use these services to store and query embeddings within Postgres.
+
+This guide covers:
+
+1. [Setting up your database](#setup-database)
+2. [Creating a SQL table](#create-a-vector-table) that can store vector data
+3. [Generating OpenAI embeddings](#generate-openai-embeddings) using OpenAI's JavaScript client
+4. [Storing the embeddings](#store-embeddings-in-database) in your SQL table using the Supabase JavaScript client
+5. [Performing semantic search](#semantic-search) over the embeddings using a Postgres function and the Supabase JavaScript client
+
+## Setup database
+
+First head over to https://database.new to provision your Supabase database. This will create a Postgres database on the Supabase cloud platform. Alternatively, you can follow the [local development](https://supabase.com/docs/guides/cli/getting-started) options if you prefer to run your database locally using Docker.
+
+In the studio, jump to the [SQL editor](https://supabase.com/dashboard/project/_/sql/new) and execute the following SQL to enable pgvector:
+
+```sql
+-- Enable the pgvector extension
+create extension if not exists vector;
+```
+
+> In a production application, the best practice is to use [database migrations](https://supabase.com/docs/guides/cli/local-development#database-migrations) so that all SQL operations are managed within source control. To keep things simple in this guide, we'll execute queries directly in the SQL Editor. If you are building a production app, feel free to move these into a database migration.
+
+## Create a vector table
+
+Next we'll create a table to store documents and embeddings. In the SQL Editor, run:
+
+```sql
+create table documents (
+ id bigint primary key generated always as identity,
+ content text not null,
+ embedding vector (1536) not null
+);
+```
+
+Since Supabase is built on Postgres, we're just using regular SQL here. You can modify this table however you like to better fit your application. If you have existing database tables, you can simply add a new `vector` column to the appropriate table.
+
+The important piece to understand is the `vector` data type, which is a new data type that became available when we enabled the pgvector extension earlier. The size of the vector (1536 here) represents the number of dimensions in the embedding. Since we're using OpenAI's `text-embedding-3-small` model in this example, we set the vector size to 1536.
+
+Let's go ahead and create a vector index on this table so that future queries remain performant as the table grows:
+
+```sql
+create index on documents using hnsw (embedding vector_ip_ops);
+```
+
+This index uses the [HNSW](https://supabase.com/docs/guides/ai/vector-indexes/hnsw-indexes) algorithm to index vectors stored in the `embedding` column, and specifically when using the inner product operator (`<#>`). We'll explain more about this operator later when we implement our match function.
+
+Let's also follow security best practices by enabling row level security on the table:
+
+```sql
+alter table documents enable row level security;
+```
+
+This will prevent unauthorized access to this table through the auto-generated REST API (more on this shortly).
+
+## Generate OpenAI embeddings
+
+This guide uses JavaScript to generate embeddings, but you can easily modify it to use any [language supported by OpenAI](https://platform.openai.com/docs/libraries).
+
+If you are using JavaScript, feel free to use whichever server-side JavaScript runtime that you prefer (Node.js, Deno, Supabase Edge Functions).
+
+If you're using Node.js, first install `openai` as a dependency:
+
+```shell
+npm install openai
+```
+
+then import it:
+
+```js
+import OpenAI from "openai";
+```
+
+If you're using Deno or Supabase Edge Functions, you can import `openai` directly from a URL:
+
+```js
+import OpenAI from "https://esm.sh/openai@4";
+```
+
+> In this example we import from https://esm.sh which is a CDN that automatically fetches the respective NPM module for you and serves it over HTTP.
+
+Next we'll generate an OpenAI embedding using [`text-embedding-3-small`](https://platform.openai.com/docs/guides/embeddings/embedding-models):
+
+```js
+const openai = new OpenAI();
+
+const input = "The cat chases the mouse";
+
+const result = await openai.embeddings.create({
+ input,
+ model: "text-embedding-3-small",
+});
+
+const [{ embedding }] = result.data;
+```
+
+Remember that you will need an [OpenAI API key](https://platform.openai.com/api-keys) to interact with the OpenAI API. You can pass this as an environment variable called `OPENAI_API_KEY`, or manually set it when you instantiate your OpenAI client:
+
+```js
+const openai = new OpenAI({
+ apiKey: "