-- 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 if 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;
$$;

DASHSCOPE_API_KEY = "sk-*****"
SUPABASE_URL = "http://*.*.*.*:*"
SUPABASE_SERVICE_KEY = "eyJhbGc****BBNWN8Bu4GE"

import os
from dotenv import load_dotenv
# import langchain
from langchain_community.document_loaders import PyPDFDirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import SupabaseVectorStore
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
# import supabase
from supabase import create_client, Client
# 加载环境变量
load_dotenv()
# 获取配置
# supabase_url = os.environ.get("SUPABASE_URL") 
# supabase_key = os.environ.get("SUPABASE_SERVICE_KEY")
# 简化初始化
supabase: Client = create_client(supabase_url, supabase_key)
# initiate embeddings model
embeddings = DashScopeEmbeddings(model="text-embedding-v2", dashscope_api_key=os.environ.get("DASHSCOPE_API_KEY"))
# load pdf docs from folder 'documents'
loader = PyPDFDirectoryLoader("documents")
# split the documents in multiple chunks
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
docs = text_splitter.split_documents(documents)
# store chunks in vector store
vector_store = SupabaseVectorStore.from_documents(
    docs,
    embeddings,
    client=supabase,
    table_name="documents",
    query_name="match_documents",
    chunk_size=1000,
)

# import basics
import os
from dotenv import load_dotenv
from langchain.agents import AgentExecutor
from langchain.agents import create_tool_calling_agent
from langchain_community.vectorstores import SupabaseVectorStore
from langchain import hub
from supabase.client import Client, create_client
from langchain_core.tools import tool
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain_community.chat_models.tongyi import ChatTongyi
# load environment variables
load_dotenv()  
# initiate supabase database
supabase_url = os.environ.get("SUPABASE_URL")
supabase_key = os.environ.get("SUPABASE_SERVICE_KEY")
supabase: Client = create_client(supabase_url, supabase_key)
# initiate embeddings model
# embeddings = OpenAIEmbed dings(model="text-embedding-3-small")
embeddings = DashScopeEmbeddings(model="text-embedding-v2", dashscope_api_key=os.environ.get("DASHSCOPE_API_KEY"))
# initiate vector store
vector_store = SupabaseVectorStore(
    embedding=embeddings,
    client=supabase,
    table_name="documents",
    query_name="match_documents",
)
# initiate large language model (temperature = 0)
# llm = ChatOpenAI(temperature=0)
llm = ChatTongyi(streaming=True)
# fetch the prompt from the prompt hub
prompt = hub.pull("hwchase17/openai-functions-agent")
# create the tools
@tool(response_format="content_and_artifact")
def retrieve(query: str):
    """Retrieve information related to a query."""
    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join(
        (f"Source: {doc.metadata}\n" f"Content: {doc.page_content}")
        for doc in retrieved_docs
    )
    return serialized, retrieved_docs
# combine the tools and provide to the llm
tools = [retrieve]
agent = create_tool_calling_agent(llm, tools, prompt)
# create the agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# invoke the agent
response = agent_executor.invoke({"input": "why is agentic rag better than naive rag?"})
# put the result on the screen
print(response["output"])

streamlit run agentic_rag_streamlit.py

# import basics
import os
from dotenv import load_dotenv
# import streamlit
import streamlit as st
# import langchain
from langchain.agents import AgentExecutor
from langchain_openai import ChatOpenAI
from langchain_core.messages import AIMessage, HumanMessage
from langchain.agents import create_tool_calling_agent
from langchain import hub
from langchain_community.vectorstores import SupabaseVectorStore
from langchain_openai import OpenAIEmbeddings
from langchain_core.tools import tool
# import supabase db
from supabase.client import Client, create_client
from langchain_community.embeddings.dashscope import DashScopeEmbeddings
from langchain_community.chat_models.tongyi import ChatTongyi
# load environment variables
load_dotenv()  
# initiating supabase
supabase_url = os.environ.get("SUPABASE_URL")
supabase_key = os.environ.get("SUPABASE_SERVICE_KEY")
supabase: Client = create_client(supabase_url, supabase_key)
# initiating embeddings model
embeddings = DashScopeEmbeddings(model="text-embedding-v2", dashscope_api_key=os.environ.get("DASHSCOPE_API_KEY"))
# initiating vector store
vector_store = SupabaseVectorStore(
    embedding=embeddings,
    client=supabase,
    table_name="documents",
    query_name="match_documents",
)
 
# initiating llm
llm = ChatTongyi(streaming=True)
# pulling prompt from hub
prompt = hub.pull("hwchase17/openai-functions-agent")
# creating the retriever tool
@tool(response_format="content_and_artifact")
def retrieve(query: str):
    """Retrieve information related to a query."""
    retrieved_docs = vector_store.similarity_search(query, k=2)
    serialized = "\n\n".join(
        (f"Source: {doc.metadata}\n" f"Content: {doc.page_content}")
        for doc in retrieved_docs
    )
    return serialized, retrieved_docs
# combining all tools
tools = [retrieve]
# initiating the agent
agent = create_tool_calling_agent(llm, tools, prompt)
# create the agent executor
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# initiating streamlit app
st.set_page_config(page_title="Agentic RAG Chatbot", page_icon="🦜")
st.title("🦜 Agentic RAG Chatbot")
# initialize chat history
if "messages" not in st.session_state:
    st.session_state.messages = []
# display chat messages from history on app rerun
for message in st.session_state.messages:
    if isinstance(message, HumanMessage):
        with st.chat_message("user"):
            st.markdown(message.content)
    elif isinstance(message, AIMessage):
        with st.chat_message("assistant"):
            st.markdown(message.content)
# create the bar where we can type messages
user_question = st.chat_input("How are you?")
# did the user submit a prompt?
if user_question:
    # add the message from the user (prompt) to the screen with streamlit
    with st.chat_message("user"):
        st.markdown(user_question)
        st.session_state.messages.append(HumanMessage(user_question))
    # invoking the agent
    result = agent_executor.invoke({"input": user_question, "chat_history":st.session_state.messages})
    ai_message = result["output"]
    # adding the response from the llm to the screen (and chat)
    with st.chat_message("assistant"):
        st.markdown(ai_message)
        st.session_state.messages.append(AIMessage(ai_message))