init

app.py

@@ -0,0 +1,90 @@
+import streamlit as st
+from langchain_groq import ChatGroq
+from apps.agent.constant import GROQ_API_KEY, MODEL_GROQ, CONFIG
+from apps.agent.graph import Agent
+
+
+llm = ChatGroq(model=MODEL_GROQ, api_key=GROQ_API_KEY, temperature=0.1)
+
+
+agent = Agent(llm=llm)
+
+
+def get_response(query: str):
+    response = agent.graph.invoke({"messages": ("user", query)}, CONFIG)
+    return response["messages"][-1].content
+
+with st.sidebar:
+    st.header("Prof of Concept")
+    st.markdown(
+        """
+        This is just a prototype chatbot, the data taken is based on the following sites:
+        Xano Documentation
+        - https://docs.xano.com/about
+        - https://releases.xano.com/?_gl=1*sifgtw*_ga*MTI5NTY3MTk5NS4xNzMwNjMzNjY3*_ga_EJWDZRK3CG*MTczMDgwNjg3Mi43LjEuMTczMDgwNjkyMy45LjAuODUyNzA5OTA4
+        - https://docs.xano.com/onboarding-tutorial-reference
+        - https://docs.xano.com/faq
+        - https://docs.xano.com/about
+        - https://docs.xano.com/what-xano-includes
+        - https://docs.xano.com/what-xano-includes/instance
+        - https://docs.xano.com/what-xano-includes/workspace
+        - https://docs.xano.com/database/triggers
+        - https://docs.xano.com/fundamentals/the-development-life-cycle    
+
+        WeWeb Documentation
+        - https://docs.weweb.io/start-here/welcome.html
+        - https://docs.weweb.io/start-here/frequently-asked-questions.html
+        - https://docs.weweb.io/editor/intro-to-the-editor.html
+        - https://docs.weweb.io/editor/intro-to-html-css.html
+        - https://docs.weweb.io/editor/how-to-use-the-add-panel.html
+        - https://docs.weweb.io/editor/logs.html
+        - https://docs.weweb.io/editor/copilot/import-figma-designs.html
+        - https://docs.weweb.io/editor/app-settings/app-settings.html
+        - https://docs.weweb.io/editor/app-settings/pwa.html
+"""
+    )
+
+    st.header("Example Question")
+    st.markdown(
+        """
+        Note: When asking a question, always add the word **xeno** or **weweb** so that the agent can easily find an accurate answer.
+
+        - What is PWA? and how enabling mobile app features in Weweb?
+        - How installing a PWA on a phone in WeWeb?
+        - Will the Marketplace have templates that I can use to start my backend with?
+        - Can I scale my backend with Xano?
+        """
+    )
+
+st.title("AI Agent Assistance")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+for message in st.session_state.messages:
+    role = message.get("role", "assistant")
+    with st.chat_message(role):
+        if "output" in message:
+            st.markdown(message["output"])
+
+
+if prompt := st.chat_input("What do you want to know?"):
+    st.chat_message("user").markdown(prompt)
+    st.session_state.messages.append({"role": "user", "output": prompt})
+
+    with st.spinner("Searching for an answer..."):
+        output_text = get_response(prompt)
+        print("Output", output_text)
+
+    # Display assistant response and SQL query
+    st.chat_message("assistant").markdown(output_text)  # Kenapa ini tidak muncul di UI?
+    
+
+    # Append assistant response to session state
+    st.session_state.messages.append(
+        {
+            "role": "assistant",
+            "output": output_text,
+        }
+    )
+

apps/agent/constant.py

@@ -0,0 +1,26 @@
+import os
+from langchain_core.prompts import ChatPromptTemplate
+
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+MODEL_GROQ = "llama-3.1-8b-instant"
+INDEX_NAME_XANO = "xano-index"
+INDEX_NAME_WEWEB = "weweb-index"
+
+CONFIG = {
+    "configurable" : {
+        "thread_id": "1234"
+    }
+}
+
+PROMPT = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            "You are a knowledgeable instructor. Your job is to help students learn a tool, the data for which is retrieved from a documentation site"
+            "Answer questions directly and clearly, as if you were explaining to a student who needs precise and structured guidance."
+            "If the answer doesn't fit the given context, just say I don't have the information for that."
+        ),
+        ("placeholder", "{messages}")
+    ]
+)

apps/agent/graph.py

@@ -0,0 +1,88 @@
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.store.memory import InMemoryStore
+from langgraph.graph import StateGraph, START, END
+from langgraph.prebuilt import ToolNode
+from langchain_core.runnables import Runnable
+from langchain_core.messages import AIMessage, ToolMessage
+from langgraph.prebuilt import tools_condition
+
+from langchain_groq import ChatGroq
+from apps.agent.tools import tool_weweb, tool_xano    # kalo run api pake ini -> app.agent.tools
+from apps.agent.state import State, RequestAssistance
+from apps.agent.constant import PROMPT
+
+
+class Agent:
+    def __init__(self, llm: ChatGroq, memory=MemorySaver(), store=InMemoryStore() , prompt=PROMPT):
+        self.llm = llm
+        self.memory = memory
+        self.store = store
+        self.tools = [tool_xano, tool_weweb]
+        llm_with_tools = prompt | self.llm.bind_tools(self.tools + [RequestAssistance])
+
+        builder = StateGraph(State)
+        builder.add_node("chatbot", Assistant(llm_with_tools))
+        builder.add_node("tools", ToolNode(self.tools))
+        builder.add_node("human", self._human_node)
+        builder.add_conditional_edges(
+            "chatbot",
+            tools_condition,
+            {"human": "human", "tools": "tools", END: END},
+        )
+
+        builder.add_edge("tools", "chatbot")
+        builder.add_edge("human", "chatbot")
+        builder.add_edge(START, "chatbot")
+            
+        self.graph = builder.compile(
+            checkpointer=self.memory,
+            store=self.store,
+            interrupt_after=["human"]
+        )
+    
+    def _create_response(self, response: str, ai_message: AIMessage):
+        return ToolMessage(
+            content=response,
+            tool_call_id=ai_message.tool_calls[0]["id"],
+        )
+    
+    def _human_node(self, state: State):
+        new_messages = []
+        if not isinstance(state["messages"][-1], ToolMessage):
+            # Typically, the user will have updated the state during the interrupt.
+            # If they choose not to, we will include a placeholder ToolMessage to
+            # let the LLM continue.
+            new_messages.append(
+                self._create_response("No response from human.", state["messages"][-1])
+            )
+        return {
+            # Append the new messages
+            "messages": new_messages,
+            # Unset the flag
+            "ask_human": False,
+        }
+    
+
+    def _select_next_node(self, state: State):
+        if state["ask_human"]:
+            return "human"
+            # Otherwise, we can route as before
+        return tools_condition(state)
+
+
+class Assistant:
+    def __init__(self, runnable: Runnable):
+        self.runnable = runnable
+
+    def __call__(self, state):
+        while True:
+            response = self.runnable.invoke(state)
+            # If the LLM happens to return an empty response, we will re-prompt it
+            # for an actual response.
+            ask_human = False
+
+            if (
+                response.tool_calls and response.tool_calls[0]["name"] == RequestAssistance.__name__
+            ):
+                ask_human = True
+            return {"messages": [response], "ask_human": ask_human}

apps/agent/state.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+from typing_extensions import TypedDict
+from langgraph.graph.message import add_messages, AnyMessage
+from typing import Annotated, List
+
+class State(TypedDict):
+    messages: Annotated[List[AnyMessage], add_messages]
+    ask_human: bool
+
+class RequestAssistance(BaseModel):
+    """
+    Escalate the conversation to an expert. Use this if you are unable to assist directly or if the user requires support beyond your permissions.
+    To use this function, relay the user's 'request' so the expert can provide the right guidance.
+    """
+    request: str
+

apps/agent/tools.py

@@ -0,0 +1,37 @@
+import os
+from langchain_community.vectorstores.pinecone import Pinecone
+from langchain_community.embeddings.fastembed import FastEmbedEmbeddings
+from langchain.retrievers import ContextualCompressionRetriever
+from langchain.retrievers.document_compressors import FlashrankRerank
+from langchain_core.tools import tool
+
+from apps.agent.constant import INDEX_NAME_WEWEB, INDEX_NAME_XANO
+
+# os.environ["PINECONE_API_KEY"] = "a526d62f-ccca-40d6-859b-3d878c8d288b"
+
+embeddings = FastEmbedEmbeddings(model_name="BAAI/bge-small-en-v1.5")
+compressor = FlashrankRerank()
+
+def create_compressed_retriever(index_name: str, embeddings, compressor) -> ContextualCompressionRetriever:
+    vectorstore = Pinecone.from_existing_index(embedding=embeddings, index_name=index_name)
+    retriever = vectorstore.as_retriever()
+    return ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever)
+
+reranker_xano = create_compressed_retriever(INDEX_NAME_XANO, embeddings, compressor)
+reranker_weweb = create_compressed_retriever(INDEX_NAME_WEWEB, embeddings, compressor)
+
+@tool
+def tool_xano(query: str):
+    """
+    Searches and returns excerpts from the Xano documentation
+    """
+    docs = reranker_xano.invoke(query)
+    return "\n\n".join([doc["page_content"] for doc in docs])
+
+@tool
+def tool_weweb(query: str):
+    """
+    Searches and returns excerpts from the Weweb documentation
+    """
+    docs = reranker_weweb.invoke(query)
+    return "\n\n".join([doc["page_content"] for doc in docs])

apps/models.py

@@ -0,0 +1,4 @@
+from pydantic import BaseModel
+
+class QueryInput(BaseModel):
+    query: str

apps/service.py

@@ -0,0 +1,53 @@
+import logging
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from langgraph.errors import GraphRecursionError
+from langchain_groq import ChatGroq
+from apps.models import QueryInput
+from apps.agent.graph import Agent
+from apps.agent.constant import GROQ_API_KEY, MODEL_GROQ, CONFIG
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+llm = ChatGroq(model=MODEL_GROQ, api_key=GROQ_API_KEY, temperature=0.1)
+agent = Agent(llm=llm)
+
+app = FastAPI(
+    title="Agent API",
+    description="API to interact with the RAG agent.",
+    version="0.1.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json",
+)
+
+@app.get("/", summary="API Health Check", tags=["Health"])
+async def health_check():
+    """Endpoint for checking the API status."""
+    return {"status": "API is running"}
+
+
+@app.post("/query-agent", summary="Query the RAG Agent", tags=["Agent"])
+async def query_rag_agent(query: QueryInput):
+    """ """
+    try:
+        output = agent.graph.invoke({"messages": ("user", query.query)}, CONFIG)
+    
+        response = output["messages"][-1].content
+        
+        logger.info(f"Processed query successfully: {query.query}")
+
+        return JSONResponse(
+            content={"response": response},
+            media_type="application/json",
+            status_code=200
+        )
+
+    except GraphRecursionError:
+        logger.error("Graph recursion limit reached; query processing failed.")
+        raise HTTPException(
+            status_code=500,
+            detail="Recursion limit reached. Could not generate response despite 25 attempts."
+        )

run_api.py

@@ -0,0 +1,5 @@
+import uvicorn
+from apps.service import app
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)