DEV Community: sreejinsreenivasan

Supabase: A Guide to Setting Up Your Local Environment

sreejinsreenivasan — Thu, 18 Apr 2024 07:24:42 +0000

Supabase, an open-source alternative to Firebase, offers a comprehensive suite of tools to streamline your development process. In this guide, we'll walk through the steps to set up your local environment with Supabase, empowering you to build and test your applications with ease.

Why Develop Locally with Supabase?

Before we delve into the setup process, let's explore why developing locally with Supabase is advantageous:

Faster Development: Eliminates network latency and internet disruptions, speeding up the development process.
Easier Collaboration: Facilitates seamless collaboration with team members on the same project.
Cost-Effective: Allows for unlimited local projects, reducing costs compared to using multiple live projects.
Configuration in Code: Stores table schemas in code for better organization and version control.
Work Offline: Enables developers to work from anywhere without requiring constant internet access.

By setting up a local development environment with Supabase, you can streamline your workflow, improve productivity, and ensure a more reliable and cost-effective development experience.

Sources

Supabase documentation and developer resources.

Prerequisites

Before proceeding with setting up the local development environment for Supabase, ensure that the following prerequisites are met:

Node.js and npm:
- Your local development environment should have Node.js and npm (the Node.js package manager) installed.
- These dependencies are necessary for managing Supabase-related packages and running the Supabase CLI.
Docker Installed and Running:
- Docker is required to run the Supabase stack locally.
- Ensure Docker is installed on your local machine.
- Start Docker to ensure it's running and accessible.

If Docker is not installed, you can download and install it from the official Docker website: https://www.docker.com/products/docker-desktop

Once Docker is installed, start the Docker application to ensure it's running in the background

Setting Up the Local Development Environment

Now that we've ensured our prerequisites are in place, let's proceed with setting up the local development environment for Supabase:

Install the Supabase CLI: - Open your terminal or command prompt. - Install the Supabase CLI using npm:

npm install supabase --save-dev

Initialize Your Project:
- Create a new directory for your project and navigate into it:

mkdir my-supabase-project
cd my-supabase-project

Initialize your project with the Supabase CLI:This will create the necessary files and folders for your Supabase project, such as config.toml where you can customize your local development environment settings.

npx supabase init

Start the Supabase Stack:

With your project initialized, you can now start the Supabase stack locally:

npx supabase start

This command will pull all necessary docker images and start the docker containers for the Supabase stack. You can access your local Supabase services locally, including the database, API server, and Supabase Studio.

  Started supabase local development setup.

  API URL: http://127.0.0.1:54321
  GraphQL URL: http://127.0.0.1:54321/graphql/v1
  S3 Storage URL: http://127.0.0.1:54321/storage/v1/s3
           DB URL: postgresql://postgres:postgres@127.0.0.1:54322/postgres
        Studio URL: http://127.0.0.1:54323
     Inbucket URL: http://127.0.0.1:54324
        JWT secret: super-secret-jwt-token-with-at-least-32-characters-long
        anon key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
  service_role key: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
     S3 Access Key: 625729a08b95bf1b7ff351a663f3a23c
     S3 Secret Key: 850181e4652dd023b7a98c58ae0d2d34bd4
        S3 Region: local

Access Your Local Development Environment: Once the Supabase stack is running, you can access various components via their respective URLs: - API URL: http://localhost:54321 - Database URL: postgresql://postgres:postgres@localhost:54322/postgres - Supabase Studio: http://localhost:54323 - Inbucket: http://localhost:54324

Replace Environment Variables (Optional):
- If needed, replace environment variables in your project's configuration files with the appropriate URLs and keys provided by the Supabase CLI.
NEXT_PUBLIC_SUPABASE_URL: Set this variable to http://localhost:54321. This URL points to the local Supabase instance.
NEXT_PUBLIC_SUPABASE_ANON_KEY: Obtain this key from the terminal output when running supabase start. It is generated dynamically and is specific to your local Supabase instance.

With these steps completed, your local development environment with Supabase is up and running, ready for you to start building and testing your applications.

Conclusion

Setting up a local environment with Supabase is a straightforward process that empowers developers to build and test their applications with confidence. By following the steps outlined in this guide, you can harness the full potential of Supabase and accelerate your development workflow.

Happy coding with Supabase!

Retrieval Augmented Generation on Notion with Langchain, Supabase and OpenAI

sreejinsreenivasan — Wed, 28 Feb 2024 07:08:39 +0000

RAG, or Retrieval Augmented Generation, is a prominent AI framework in the era of large language models (LLMs). It enhances the capabilities of these models by integrating external knowledge, ensuring more accurate and current responses. A standard RAG system includes an LLM, a vector database, and some prompts as code that can be send queries to the LLM.

Purpose and Goals:

Learn How to Vectorise Notion Pages and Databases: We'll delve into the process of vectorising Notion pages and databases, enabling efficient storage and retrieval of information.
Introduction to Retrieval Augmented Generation (RAG) using LangChain: We'll provide an overview of RAG and demonstrate its implementation using LangChain, a powerful tool for integrating external knowledge into AI models

In this guide, we'll explore three important tools: Notion, Supabase, and OpenAI. Notion data is the external information we are going to ingest. Supabase stores this information in a vector representation to act as the context to the LLM. First, we'll set up these tools step by step. Then, we'll learn how to take information from Notion and store it in a Vector Store. After that, we'll use LangChain to build a knowledge retrieval system that can find the right answers for us. Finally, we'll see how all these pieces work together in a real situation.

If you're interested in learning more about prompt engineering and its importance in shaping the responses of AI models, check out my previous post:Prompt Engineering for OpenAI Chat Completions. In this beginner's guide, I delve into the significance of crafting well-designed prompts to enhance the accuracy and relevance of AI-generated responses. Understanding prompt engineering can greatly improve your experience with AI models like OpenAI's Chat Completions.

Before diving into the implementation, let's ensure we have all the necessary requirements:

Notion Database: A table database in Notion with appropriate records.
Visit the Notion Developers page and log in with your Notion account.
Notion Integration: Generate an integration token in Notion to access the database programmatically.
Connect the Integration to the Database.
Supabase Setup: Set up a Supabase project and obtain the Supabase URL and service key.
Environment Variables: Set environment variables for the OpenAI API key, Supabase URL, and service key.

import os

os.environ["OPENAI_API_KEY"] = "your-openai-api-key"
os.environ["SUPABASE_URL"] = "your-supabase-url"
os.environ["SUPABASE_SERVICE_KEY"] = "your-supabase-service-key"
os.environ["NOTION_TOKEN"] = "your-notion-integration-token"
os.environ["DATABASE_ID"] = "your-notion-database-id"

Setup Supabase Database

Use these steps to setup your Supabase database if you haven't already.

Head over to https://database.new to provision your Supabase database.
In the studio, jump to the SQL editor and run the following script to enable pgvector and setup your database as a vector store:

-- Enable the pgvector extension to work with embedding vectors
create extension if not exists vector;

-- Create a table to store your documents
create table
  documents (
    id uuid primary key,
    content text, -- corresponds to Document.pageContent
    metadata jsonb, -- corresponds to Document.metadata
    embedding vector (1536) -- 1536 works for OpenAI embeddings, change as needed
  );

-- Create a function to search for documents
create function match_documents (
  query_embedding vector (1536),
  filter jsonb default '{}'
) returns table (
  id uuid,
  content text,
  metadata jsonb,
  similarity float
) language plpgsql as $$
#variable_conflict use_column
begin
  return query
  select
    id,
    content,
    metadata,
    1 - (documents.embedding <=> query_embedding) as similarity
  from documents
  where metadata @> filter
  order by documents.embedding <=> query_embedding;
end;
$$;

Loading Notion Documents with NotionDBLoader

Note: The following code only loads documents from a single Notion database. You can export your entire Notion workspace and load documents using NotionDirectoryLoader, see the ingesting-your-own-dataset from Langchain for more details.

We'll start by loading documents from a Notion database using the NotionDBLoader class. This class retrieves pages from the database, reads their content, and returns a list of Document objects.

from langchain_community.document_loaders import NotionDBLoader

NOTION_TOKEN = os.environ["NOTION_TOKEN"]
DATABASE_ID = os.environ["DATABASE_ID"]

loader = NotionDBLoader(
    integration_token=NOTION_TOKEN,
    database_id=DATABASE_ID,
    request_timeout_sec=30  # Optional, defaults to 10
)

docs = loader.load()

Storing Documents with SupabaseVectorStore

Next, we'll store the retrieved documents in Supabase using the SupabaseVectorStore. This component enables efficient storage and retrieval of indexed documents in Supabase.

from langchain_community.vectorstores import SupabaseVectorStore
from supabase.client import Client, create_client

SUPABASE_URL = os.environ["SUPABASE_URL"]
SUPABASE_SERVICE_KEY = os.environ["SUPABASE_SERVICE_KEY"]

supabase: Client = create_client(SUPABASE_URL, SUPABASE_SERVICE_KEY)
embeddings = OpenAIEmbeddings()

vector_store = SupabaseVectorStore.from_documents(
    docs,
    embeddings,
    client=supabase,
    table_name="documents",
    query_name="match_documents",
    chunk_size=500
)

In the code above, we've created a SupabaseVectorStore from the retrieved documents. The from_documents method takes the following parameters:

docs: A list of Document objects to be stored in the vector store.
embeddings: An instance of the OpenAIEmbeddings class, which provides methods for generating embeddings from text.
client: A Supabase client instance for interacting with the database.
table_name: The name of the table in the Supabase database where the documents will be stored.
query_name: The name of the function in the database that will be used for document retrieval.
chunk_size: The number of documents to be stored in each batch.

retriever = vector_store.as_retriever()
retriever.get_relevant_documents("NotionFlow")

Output:

[Document(page_content='Project Overview:\n\nNotionFlow is a comprehensive automation tool designed to streamline workflows, enhance productivity, and optimize resource allocation using Notion\'s versatile database and collaboration features.)]

In this example, we've queried the vector store with the input "NotionFlow" and retrieved a relevant document containing information about the project overview.

Performing Retrieval with OpenAI

With the documents stored in Supabase, we can leverage OpenAI's powerful language models for advanced processing tasks. We'll use the ChatOpenAI class to interact with the OpenAI model.

from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain import hub

prompt = hub.pull("rlm/rag-prompt")
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=1)

def format_docs(docs):
    return "\\n\\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

Let's break down the RAG pipeline:

Retriever: The retriever component retrieves documents from the Supabase vector store based on the input query.
Prompt: The prompt component provides a structured prompt for the OpenAI language model, guiding it to generate a response based on the retrieved documents.
LLM: The llm component represents the large language model (LLM) from OpenAI, which processes the prompt and generates a response.
Output Parser: The StrOutputParser component parses the output from the LLM and formats it as a string for further processing.

Let's query the RAG pipeline with a sample input and retrieve the generated response.

rag_chain.invoke("What are the main features of NotionFlow?")

Output:

NotionFlow features include automation triggers for project creation, task completion notifications, content idea generation, content calendar updates, goal progress tracking, cross-database relationships, bug report handling, and customer feedback integration. The tool is designed to streamline workflows, enhance productivity, and improve resource allocation through automation and integration with Notion's collaboration features. Its benefits include streamlining project management processes, enhancing collaboration and communication, and enabling data-driven decision-making.

Conclusion

In this tutorial, we've demonstrated how to build a RAG pipeline using LangChain, OpenAI, and Supabase. By combining the capabilities of these tools we can query a custom knowledge base and generate responses based on the retrieved documents.

Resources

Next Steps

The RAG pipeline we've built is a basic example of how to ingest and retrieve documents from a knowledge base. You can further enhance the pipeline by ingesting more documents, fine tuning the chunk size, and experimenting with different prompts to generate more accurate responses. Additionally, you can explore other components and integrations available in LangChain to build more advanced language processing pipelines.

Stay Connected

Join me on LinkedIn, where I share insights and updates on AI, Automation, Productivity, and more.

Connect with me on LinkedIn

Additionally, if you're interested in learning more about how I'm leveraging AI for simple automations and productivity hacks, subscribe to my newsletter "Growth Journal". Be the first to receive exclusive content and stay up-to-date with the latest trends in AI and automation.

Subscribe to my newsletter

Until next time, happy prompting!

Prompt Engineering for OpenAI Chat Completions

sreejinsreenivasan — Mon, 19 Feb 2024 11:47:57 +0000

A prompt, essentially a piece of text, is what we offer to the model to steer its response. The quality and clarity of the prompt directly influence the accuracy and relevance of the generated responses. With well-crafted prompts, developers can shape the model's understanding, context, and expected output, leading to more precise and useful responses while saving time and effort in the interaction process.

Setting Up

To get started with prompting, you'll need to set up the OpenAI Python library. Install the library using pip:

pip install openai

Once the library is installed, the next step is to import the OpenAI library and set your API key:

from openai import OpenAI

client = OpenAI(api_key="your-api")

Quickstart

Let's dive right in with a simple example. Suppose we want a joke about cats. Our prompt could be:

prompt = "Tell me a joke about cats"

Using the OpenAI library, we can obtain a response from the model based on this prompt:

response = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {
      "role": "user",
      "content": prompt
    }
  ],
)

response.choices[0].message.content

Output:

"Why don't cats play poker in the wild? Too many cheetahs!"

That's it! We've successfully obtained a joke about cats using a simple prompt.

Let's enhance our prompt dynamically by incorporating a placeholder for the topic:

topic = "dog"

prompt = "Tell me a joke about {topic}"

print(prompt.format(topic=topic))

What is happening here is that we are using the format method to replace the placeholder {topic} with the value of the topic variable. This results in the following prompt:

Output:

 "Tell me a joke about dog"

A helper function can be created to simplify the process of obtaining chat completions:

def get_chat_response(prompt):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
    )
    return response.choices[0].message.content

Now, we can obtain a response based on this dynamic prompt:

get_chat_response(prompt.format(topic=topic))

Output:

"Why did the dog sit in the shade? Because he didn't want to be a hot dog!"

Hilarious!

Fine-tuning Model Parameters

OpenAI allows control over model parameters such as temperature and top-p, influencing the randomness and creativity of the generated responses. Lower temperature values result in more accurate responses, while higher values foster creativity.

Let's modify our function to include a temperature parameter:


def get_chat_response(prompt, temperature=0):
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ],
        temperature=temperature,
    )
    return response.choices[0].message.content

Increasing the temperature may produce different responses:

get_chat_response(prompt.format(topic=topic), temperature=1)

Output:

"Why did the cat sit on the computer? Because it wanted to keep an eye on the mouse!"

There are many other parameters that can be used to fine-tune the model's behavior, such as max_tokens, top_p, and presence_penalty etc.

Use max_tokens to control the length of the response. For example, setting max_tokens=20 will limit the response to 20 tokens. This is useful for controlling the prevent the model from generating overly long responses, and save resources.

Elements of a Good Prompt

A good prompt is clear, concise, and specific, providing enough context for the model to understand the user's intent and generate a relevant response. Here are key elements to consider:

Instruction: Clearly state the task or instruction you want the model to perform.
Context: Provide external information or additional context to steer the model towards better responses.
Input Data: Offer the input or question for which you seek a response.
Output Indicator: Specify the type or format of the desired output.

Crafting Complex Prompts

This examples are very basic. For generating more complex and specific responses, we can use more advanced prompts and context to guide the model's understanding.

Let's say I want to generate a weekly plan based on specific goals.

prompt = """Efficiently plan the week to achieve all goals while maximizing productivity and allowing time for relaxation.\

Goals of the week:\

1. Complete development sprint for project X.\
2. Lead team meeting to discuss project updates and assign tasks.\
3. Research and prototype innovative features for product Y.\
4. Attend networking event to expand professional network.\
5. Review industry trends and advancements for potential business opportunities.\
"""

let's see what the model comes up with for this prompt:

get_chat_response(prompt, temperature=1)

Output:

To efficiently plan the week and achieve all goals while maximizing productivity and allowing time for relaxation, consider the following schedule:

Monday:
- Start the day by reviewing project X and outlining tasks for the development sprint.
- Lead team meeting in the afternoon to discuss project updates and assign tasks accordingly.
- Dedicate time in the evening to research and prototype innovative features for product Y.

Tuesday:
- Focus on completing tasks for project X development sprint.
- Attend the networking event in the evening to expand professional network.

Wednesday:
- Review industry trends and advancements in the morning for potential business opportunities.
- Continue working on project X development sprint in the afternoon.
- Allocate time in the evening for relaxation and self-care.

Thursday:
- Finalize development sprint for project X and prepare for presentation or review.
- Work on prototyping innovative features for product Y in the afternoon.

Friday:
- Present completed development sprint for project X to the team.
- Follow up with any additional tasks or updates from the team meeting.
- Reflect on the week's accomplishments and plan for the following week.

Throughout the week, ensure to prioritize tasks, allocate time for breaks and relaxation, and maintain open communication with the team. By organizing tasks and allocating time effectively, you can achieve all goals while also maintaining a healthy work-life balance.

That's nice! The model has generated a detailed plan for the week based on the provided goals. But the generated output does have a chatgpt conversational style to it.

The Prompt does provide a clear instruction, context and input data. But in order to get a more structured output, we can provide an output indicator to the prompt.

Few Shot Prompting

Few-shot learning is a technique that allows models to learn from a small number of examples or instructions. This can be particularly useful when you want to guide the model's understanding with specific examples or context.

Let's modify the prompt to include an output indicator:

prompt = """Efficiently plan the week to achieve all goals while maximizing productivity and allowing time for relaxation.

Goals of the week:
1. Generate an end-to-end plan for automating task creation in Notion using LLMs.
2. Conduct necessary research before diving into automation.
3. Consolidate the plan and generate sprints and tasks to complete the automation.
4. Learn Prompt Engineering for developers using OpenAI.
5. Complete development sprint for project X.
6. Lead team meeting to discuss project updates and assign tasks.
7. Research and prototype innovative features for product Y.
8. Attend networking event to expand professional network.
9. Review industry trends and advancements for potential business opportunities.

Output Format:

9:00 AM - 10:30 AM: Task 1
10:30 AM - 11:00 AM: Break
11:00 AM - 12:30 PM: Task 2
12:30 PM - 1:30 PM: Lunch
1:30 PM - 3:00 PM: Task 3
3:00 PM - 3:30 PM: Break
3:30 PM - 5:00 PM: Task 4

Example Outputs:
Monday, 12/02/2024

- 9:00 AM - 10:30 AM: Brainstorming session for innovative Notion automation ideas
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Research session on latest AI advancements for task automation
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Prototyping session for Notion automation features
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Review and refine Notion automation plan
"""

Now, let's see what the model comes up this time:

**Tuesday, 12/03/2024**

- 9:00 AM - 10:30 AM: Learn Prompt Engineering for developers using OpenAI
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue learning Prompt Engineering for developers
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Apply Prompt Engineering knowledge to project work
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Attend team meeting to discuss project updates and assign tasks

**Wednesday, 12/04/2024**

- 9:00 AM - 10:30 AM: Research and prototype innovative features for product Y
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue research and prototyping for product Y
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Networking event to expand professional network
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Review industry trends and advancements for potential business opportunities

**Thursday, 12/05/2024**

- 9:00 AM - 10:30 AM: Generate an end-to-end plan for automating task creation in Notion using LLMs
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Conduct necessary research before diving into automation
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Consolidate the plan and generate sprints and tasks to complete the automation
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Continue working on automation plan and tasks

**Friday, 12/06/2024**

- 9:00 AM - 10:30 AM: Complete development sprint for project X
- 10:30 AM - 11:00 AM: Break
- 11:00 AM - 12:30 PM: Continue development sprint for project X
- 12:30 PM - 1:30 PM: Lunch
- 1:30 PM - 3:00 PM: Finish up any pending tasks for project X
- 3:00 PM - 3:30 PM: Break
- 3:30 PM - 5:00 PM: Wrap up any remaining tasks and prepare for next week's goals

Now that's some detailed planning! The model has generated a weekly schedule based on the specific goals provided in the prompt. This demonstrates how prompts can be used to guide the model's understanding and generate specific, relevant outputs.

We successfully used few-shot learning to guide the model's understanding and generate specific outputs based on the provided examples.

Conclusion and What's Next

There are other advanced techniques such chain-of-thought (CoT), and Tree of Thoughts (ToT) etc, which can enhance the capabilities of these models for a wide range of applications, from simple conversations to complex problem-solving tasks.

I encourage you to read the source material at PromptingGuide.ai To delve deeper into prompting techniques.

Stay Connected

Join me on LinkedIn, where I share insights and updates on AI, Automation, Productivity, and more.

Connect with me on LinkedIn

Subscribe to my newsletter

Until next time, happy prompting!