Using Stripe Docs in your RAG pipeline with LlamaIndex
Tags: rag, python, ai, tutorial
Published: 2024-02-14 21:45:48

---
title: Using Stripe Docs in your RAG pipeline with LlamaIndex
published: true
description: By utilizing LlamaIndex, OpenAI, and Pinecone, we build a Python script that enables users to ask questions about Stripe Docs, augmenting the knowledge base to provide intelligent responses.
tags: rag,python,ai,tutorial
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/s9zw6f62mqvd3mze39oz.jpg
# published_at: 
---

Generative AI applications become extremely powerful when you augment them with up-to-date, domain-specific, or private data. This technique is called Retrieval Augmented Generation (RAG). 

In this post we’ll build a Python script that uses [StripeDocs Reader](https://llamahub.ai/l/readers/llama-index-readers-stripe-docs), a loader on [LlamaIndex](https://www.llamaindex.ai/), that creates vector embeddings of Stripe's documentation in [Pinecone](https://www.pinecone.io/). This allows a user to ask questions about Stripe Docs to an LLM, in this case [OpenAI](https://openai.com/), and receive a generated response.

> These techniques are similar to what we use to power [Stripe Docs AI](https://stripe.com/newsroom/news/stripe-and-openai) today. Which, when on [Stripe Docs](https://docs.stripe.com/) and logged in to a Stripe account you can try for yourself.

{% embed https://youtu.be/mTX1esg30D4 %}


##Requirements
This project requires an account and API key from both OpenAI and Pinecone. OpenAI provides the LLM that will generate an output based on a question. Pinecone provides a vector database that will allow us to search for relevant Stripe documentation prior to injecting them into our LLM prompt.

##Setup

For this project, we’ll be using Python. It is a very popular language for AI development.

1\. Create an OpenAI account and [get your API key](https://help.openai.com/en/articles/4936850-where-do-i-find-my-api-key).

2\. Create a Pinecone account and [get your API key](https://docs.pinecone.io/docs/quickstart#2-get-your-api-key).

3\. Save your API keys in a `.env` file.

```
PINECONE_API_KEY=abc_12345
OPENAI_API_KEY=abc_12345
```

4\. Create a `requirements.txt` file with the following dependencies:

```
llama-hub==0.0.77
llama-index==0.9.40
pinecone-client==3.0.2
python-dotenv==1.0.1
```

5\. Install the dependencies.

```
pip install -r requirements.txt
```

##Building your vector store and index
In order to determine which Stripe Docs are relevant to a user’s question, we’ll first have to create a vector store and index in Pinecone. The entire Stripe documentation corpus will be used to create vector embeddings, which will be searched over when determining what documents relate to a user’s question.

Parsing all Stripe Docs and turning them into embeddings is no small feat. With the [StripeDocsReader](https://llamahub.ai/l/readers/llama-index-readers-stripe-docs), you don’t worry about any of that. 

The loader navigates to [Stripe’s sitemap](https://stripe.com/sitemap/sitemap.xml) and recursively loads all of Stripe’s documentation, processes it, and makes it easy to create embeddings out of the documentation.

> Note: building the Pinecone index takes quite a bit of time, so you might want to grab a coffee while you wait.

1\. Create a `build.py` file and load the appropriate packages and environment variables.

```python
import os
import pinecone from llama_index
import VectorStoreIndex, download_loader, StorageContext from llama_index.vector_stores
import PineconeVectorStore from dotenv 
import load_dotenv

load_dotenv()

PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

# Make sure the API keys have been loaded correctly
if not OPENAI_API_KEY:
    raise Exception("OPENAI_API_KEY environment not set")

if not PINECONE_API_KEY:
    raise Exception("PINECONE_API_KEY environment not set")

# Set the Open AI API key
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
```

2\. Set up the [StripeDocsReader](https://llamahub.ai/l/readers/llama-index-readers-stripe-docs) loader from LlamaIndex.

```python
StripeDocsReader = download_loader("StripeDocsReader")
loader = StripeDocsReader()

# Iterate through all Stripe Docs using StripeDocsReader 
documents = loader.load_data()
```

You can pass the `filters` parameter to `StripeDocsReader` to narrow the corpus to a subset of Stripe Docs. See the [StripeDocsReader documentation](https://llamahub.ai/l/readers/llama-index-readers-stripe-docs) for an example.

3\. Initialize a Pinecone index that will be used to search for relevant Stripe documentation.

```python
# Initialize Pinecone index
# https://docs.llamaindex.ai/en/stable/examples/vector_stores/PineconeIndexDemo.html
pc = Pinecone(api_key=PINECONE_API_KEY)
if "stripe-docs" not in pc.list_indexes().names():
    pc.create_index(
        name="stripe-docs",
        dimension=1536,
        metric='euclidean',
        spec=ServerlessSpec(
            cloud='aws',
            region='us-west-2'
        )
    )

pinecone_index = pc.Index("stripe-docs")
```

4\. Create a vector store with your Pinecone index and add Stripe Docs to it.

```python
# Create the vector store and index
# https://docs.llamaindex.ai/en/stable/understanding/indexing/indexing.html
vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, show_progress=True, storage_context=storage_context)
```

5\. Run your build script: 

```
python build.py
```

##Using RAG with Stripe documentation

Now that you’ve set up your Pinecone vector store and created an index out of Stripe’s documentation, it’s time to query the index. When using LlamaIndex to answer a user’s question, the library will automatically retrieve relevant Stripe Docs, post-process them, and send them to ChatGPT along with your prompt.

1\. Create a `query.py` file and load the appropriate packages and environment variables,

```python
import os
import pinecone
from llama_index import VectorStoreIndex, download_loader, StorageContext
from llama_index.vector_stores import PineconeVectorStore
from dotenv import load_dotenv

load_dotenv()

PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

# Make sure the API keys have been loaded correctly
if not OPENAI_API_KEY:
    raise Exception("OPENAI_API_KEY environment not set")

if not PINECONE_API_KEY:
    raise Exception("PINECONE_API_KEY environment not set")

# Set the Open API key
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
```

2\. Initialize the existing Pinecone index.
```python
# Initialize Pinecone index
pc = Pinecone(api_key=PINECONE_API_KEY)
pinecone_index = pc.Index("stripe-docs")
```

3\. Initialize a query engine from the Pinecone vector store.

```python
# Create the vector store and index
vector_store = PineconeVectorStore(pinecone_index=pinecone_index)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_vector_store(vector_store, show_progress=True, storage_context=storage_context)

# Create the query engine
query_engine = index.as_query_engine(response_mode="refine")
```

We use `response_mode=”refine”` to create more detailed responses.

4\. Prompt for user input and query the query engine.

```python
print("How can I help you today?")
q = input()

# Querying has the following steps:
# 1. Retrieve documents from the index
# 2. Post-process the documents
# 3. Send the prompt + documents to an LLM
# https://docs.llamaindex.ai/en/stable/understanding/querying/querying.html
res = query_engine.query(f"""
You are a world-class expert at Stripe integrations.

Your job is to provide detailed answers to help Stripe users integrate their products with Stripe.

I will provide you with relevant Stripe documentation. You will provide detailed answers to the questions asked.

NEVER tell users to read the documentation or contact Stripe support. Always provide the answer directly.

Use citations when possible.

Use real code examples when applicable.

You have been asked the following question: {q}""")

print(f"""\n{res}""")
```

5\. Run your query script to try asking ChatGPT a question about Stripe, augmented by the Stripe Docs:

```
python query.py
```

{% embed https://youtu.be/O59MUpyUjK4 %}

##Conclusion

In this post, we’ve explored how to augment generative AI applications using the Stripe documentation. Although RAG is a complex process, LlamaIndex and the StripeDocsReader loader make it easy to get started. Using the default settings for document chunking, retrieving, and querying, we can create something that resembles [Stripe Docs AI](https://docs.stripe.com). The quality of responses can be greatly improved by tweaking the knobs provided by LlamaIndex.

Take a look at the [code on GitHub](https://github.com/amorriscode/stripe-docs-reader-demo).