Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

README.md

@@ -1,12 +1,6 @@
 ---
-title: Src
-emoji: 🏢
-colorFrom: red
-colorTo: pink
+title: src
+app_file: gradio_app.py
 sdk: gradio
 sdk_version: 5.20.1
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

__init__.py

@@ -0,0 +1 @@
+# This file can be empty - it just marks the directory as a Python package 

app.py

@@ -0,0 +1,177 @@
+import os
+import streamlit as st
+import requests
+import uuid
+import time
+from datetime import datetime, timedelta
+
+# Get the API URL from environment variable or use default
+API_URL = os.getenv('API_URL', 'http://localhost:8000')
+
+# Set session timeout to 15 minutes
+SESSION_TIMEOUT = 15 * 60  # 15 minutes in seconds
+# Set API request timeout to 60 seconds for local development
+API_TIMEOUT = 60  # seconds
+
+st.title("Longevity Assistant")
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.last_activity = datetime.now()
+    
+    # Get welcome message from API
+    try:
+        welcome_response = requests.get(f"{API_URL}/welcome", timeout=API_TIMEOUT)
+        if welcome_response.status_code == 200:
+            welcome_data = welcome_response.json()
+            
+            # Add assistant welcome message to chat history
+            st.session_state.messages.append({
+                "role": "assistant", 
+                "content": welcome_data["welcome_message"],
+                "links": []
+            })
+            
+            # Store suggested questions
+            st.session_state.suggested_questions = welcome_data.get("suggested_questions", [])
+        else:
+            # Fallback welcome message if API fails
+            st.session_state.messages.append({
+                "role": "assistant", 
+                "content": "Welcome to the Longevity Assistant! How can I help you today?",
+                "links": []
+            })
+            st.session_state.suggested_questions = []
+    except Exception as e:
+        st.error(f"Error connecting to the server: {str(e)}")
+        # Fallback welcome message if API fails
+        st.session_state.messages.append({
+            "role": "assistant", 
+            "content": "Welcome to the Longevity Assistant! How can I help you today?",
+            "links": []
+        })
+        st.session_state.suggested_questions = []
+
+elif "last_activity" in st.session_state:
+    # Check if session has expired
+    time_inactive = (datetime.now() - st.session_state.last_activity).total_seconds()
+    if time_inactive > SESSION_TIMEOUT:
+        # Reset session
+        st.session_state.messages = []
+        st.session_state.session_id = str(uuid.uuid4())
+    
+    # Update last activity time
+    st.session_state.last_activity = datetime.now()
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.write(message["content"])
+        #if "links" in message and message["links"]:
+            #for link in message["links"]:
+                #st.markdown(f"[{link['name']}]({link['url']})")
+
+# Display suggested questions as buttons (only if no messages from user yet)
+if len(st.session_state.messages) == 1 and hasattr(st.session_state, 'suggested_questions'):
+    st.write("Try asking about:")
+    cols = st.columns(2)
+    for i, question in enumerate(st.session_state.suggested_questions):
+        with cols[i % 2]:
+            if st.button(question, key=f"suggested_{i}"):
+                # Add user message to chat history
+                st.session_state.messages.append({"role": "user", "content": question})
+                
+                # Display user message immediately
+                with st.chat_message("user"):
+                    st.write(question)
+                
+                # Process the question (reusing the chat input logic)
+                with st.chat_message("assistant"):
+                    with st.spinner("Thinking..."):
+                        try:
+                            response = requests.post(
+                                f"{API_URL}/chat",
+                                json={"session_id": st.session_state.session_id, "message": question},
+                                timeout=API_TIMEOUT
+                            )
+                            
+                            if response.status_code == 200:
+                                response_data = response.json()
+                                # Store response for history
+                                st.session_state.messages.append({
+                                    "role": "assistant",
+                                    "content": response_data["response"],
+                                    "links": response_data["links"]
+                                })
+                                # Display the response
+                                st.write(response_data["response"])
+                                #if response_data["links"]:
+                                 #   for link in response_data["links"]:
+                                  #      st.markdown(f"[{link['name']}]({link['url']})")
+                            else:
+                                st.error(f"Error: {response.status_code}")
+                                st.session_state.messages.append({
+                                    "role": "assistant",
+                                    "content": "Sorry, I encountered an error while processing your request.",
+                                    "links": []
+                                })
+                        except Exception as e:
+                            st.error(f"Error connecting to the server: {str(e)}")
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": "Sorry, I'm having trouble connecting to the server.",
+                                "links": []
+                            })
+                
+                # Force a rerun to update the UI
+                st.rerun()
+
+# Chat input
+if prompt := st.chat_input():
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    # Display user message immediately
+    with st.chat_message("user"):
+        st.write(prompt)
+    
+    # Display assistant "thinking" message with spinner
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            # Get bot response
+            try:
+                response = requests.post(
+                    f"{API_URL}/chat",
+                    json={"session_id": st.session_state.session_id, "message": prompt},
+                    timeout=API_TIMEOUT
+                )
+                
+                if response.status_code == 200:
+                    response_data = response.json()
+                    # Store response for history
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": response_data["response"],
+                        "links": response_data["links"]
+                    })
+                    # Display the response
+                    st.write(response_data["response"])
+                    #if response_data["links"]:
+                     #   for link in response_data["links"]:
+                      #      st.markdown(f"[{link['name']}]({link['url']})")
+                else:
+                    st.error(f"Error: {response.status_code}")
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": "Sorry, I encountered an error while processing your request.",
+                        "links": []
+                    })
+            except Exception as e:
+                st.error(f"Error connecting to the server: {str(e)}")
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": "Sorry, I'm having trouble connecting to the server.",
+                    "links": []
+                })

config.py

@@ -0,0 +1,12 @@
+# Global configuration settings
+
+CONSULTATION_SETTINGS = {
+    "np_consultation_fee_usd": 50.00,  # Base consultation fee as shown in the plan example
+    "consultation_description": "Medical consultation with our Nurse Practitioner",
+    "consultation_link": "https://longevityclinic.com/consultation",
+    "consultation_disclaimers": [
+        "Required for all prescription medications",
+        "One-time fee covers review of all requested medications",
+        "Refundable if no prescriptions are approved"
+    ]
+} 

gradio_app.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import requests
+import uuid
+from datetime import datetime
+import os
+
+# Get the API URL from environment variable or use default
+API_URL = os.getenv('API_URL', 'http://localhost:8000')
+API_TIMEOUT = 60  # seconds
+
+def create_demo():
+    # Initialize state
+    session_id = str(uuid.uuid4())
+    messages = []
+    suggested_questions = []
+    
+    def get_welcome_message():
+        try:
+            welcome_response = requests.get(f"{API_URL}/welcome", timeout=API_TIMEOUT)
+            if welcome_response.status_code == 200:
+                welcome_data = welcome_response.json()
+                messages = [{"role": "assistant", "content": welcome_data["welcome_message"]}]
+                suggested_questions = welcome_data.get("suggested_questions", [])
+                return messages, gr.update(visible=True), suggested_questions
+            else:
+                fallback_message = "Welcome to the Longevity Assistant! How can I help you today?"
+                return [{"role": "assistant", "content": fallback_message}], gr.update(visible=False), []
+        except Exception as e:
+            print(f"Error connecting to server: {str(e)}")
+            fallback_message = "Welcome to the Longevity Assistant! How can I help you today?"
+            return [{"role": "assistant", "content": fallback_message}], gr.update(visible=False), []
+
+    def handle_chat(message, files, history):
+        # Add user message to history
+        history.append({"role": "user", "content": message})
+        
+        # If files were uploaded, add them to the message with distinct formatting
+        if files:
+            file_names = [f.name for f in files]
+            file_message = f"\n\n📎 *Files attached:* {', '.join(file_names)} 📎"
+            history[-1]["content"] += file_message
+        
+        try:
+            response = requests.post(
+                f"{API_URL}/chat",
+                json={"session_id": session_id, "message": message},
+                timeout=API_TIMEOUT
+            )
+            
+            if response.status_code == 200:
+                response_data = response.json()
+                history.append({"role": "assistant", "content": response_data["response"]})
+            else:
+                error_message = "Sorry, I encountered an error while processing your request."
+                history.append({"role": "assistant", "content": error_message})
+                
+        except Exception as e:
+            error_message = "Sorry, I'm having trouble connecting to the server."
+            history.append({"role": "assistant", "content": error_message})
+        
+        return "", None, history
+
+    def handle_suggested_question(question, history):
+        return handle_chat(question, None, history)
+
+    def update_question_buttons(questions):
+        updates = []
+        for i, button in enumerate(question_buttons):
+            if i < len(questions):
+                updates.append(gr.update(visible=True, value=questions[i]))
+            else:
+                updates.append(gr.update(visible=False))
+        return updates
+    
+    with gr.Blocks(css="#chatbot { height: 500px; } .upload-box { height: 40px; min-height: 40px; }") as demo:
+        gr.Markdown("# 🧬 Longevity Assistant")
+        
+        chatbot = gr.Chatbot(
+            [],
+            elem_id="chatbot",
+            height=500,
+            type="messages"
+        )
+        
+        with gr.Row():
+            txt = gr.Textbox(
+                scale=4,
+                show_label=False,
+                placeholder="Enter text and press enter",
+                container=False
+            )
+            file_output = gr.File(
+                file_count="multiple",
+                label="",
+                scale=1,
+                container=False,
+                elem_classes="upload-box"
+            )
+            btn = gr.Button("Send", scale=1)
+
+        question_list = gr.State([])
+        suggested_questions_container = gr.Column(visible=False)
+        
+        with suggested_questions_container:
+            gr.Markdown("Try asking about:")
+            question_buttons = []
+            
+            # Create 4 rows with 2 buttons each (maximum 8 suggested questions)
+            for i in range(4):
+                with gr.Row():
+                    for j in range(2):
+                        question_btn = gr.Button("", visible=False)
+                        question_btn.click(
+                            handle_suggested_question,
+                            [question_btn, chatbot],
+                            [txt, chatbot]
+                        ).then(
+                            lambda: gr.update(visible=False),
+                            None,
+                            suggested_questions_container
+                        )
+                        question_buttons.append(question_btn)
+        
+        # Update event handlers
+        txt.submit(handle_chat, [txt, file_output, chatbot], [txt, file_output, chatbot])
+        btn.click(handle_chat, [txt, file_output, chatbot], [txt, file_output, chatbot])
+        
+        # Initialize welcome message and suggested questions
+        demo.load(
+            get_welcome_message,
+            outputs=[chatbot, suggested_questions_container, question_list]
+        ).then(
+            update_question_buttons,
+            inputs=[question_list],
+            outputs=question_buttons
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_demo()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    ) 

main.py

@@ -0,0 +1,255 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+import os
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.schema import HumanMessage, SystemMessage
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain.memory import ConversationBufferMemory
+from dotenv import load_dotenv
+import openai
+import stripe  # Add stripe import
+
+# Project imports
+from src.tools import get_tools, get_supplements, get_prescription_drugs
+from src.payments.agent import process_purchase_request
+
+# Force reload environment variables from .env file
+load_dotenv(override=True)
+
+# Set OpenAI API key globally for all OpenAI services
+api_key = os.getenv("OPENAI_API_KEY")
+if not api_key:
+    raise ValueError("OPENAI_API_KEY environment variable is not set")
+elif not api_key.startswith("sk-"):
+    raise ValueError(f"Invalid API key format: {api_key[:10]}...")
+
+# Set Stripe API key
+stripe_key = os.getenv("STRIPE_API_KEY")
+if not stripe_key:
+    raise ValueError("STRIPE_API_KEY environment variable is not set")
+stripe.api_key = stripe_key
+
+# Set for the OpenAI library directly
+openai.api_key = api_key
+os.environ["OPENAI_API_KEY"] = api_key  # Ensure it's in environment variables
+
+# Print first few characters of API key for debugging (remove in production)
+print(f"Using API key starting with: {api_key[:10]}...")
+
+app = FastAPI()
+
+# Get data from tools module
+SUPPLEMENTS = get_supplements()
+PRESCRIPTION_DRUGS = get_prescription_drugs()
+
+class ChatMessage(BaseModel):
+    session_id: str
+    message: str
+
+class ChatResponse(BaseModel):
+    response: str
+    links: List[Dict[str, str]] = []
+
+# Update the in-memory storage structure
+class ChatSession:
+    def __init__(self, agent_executor: AgentExecutor, memory: ConversationBufferMemory, summary: str = ""):
+        self.agent_executor = agent_executor
+        self.memory = memory
+        self.summary = summary
+
+# Update the storage dictionary
+chat_sessions = {}  # Replace chat_histories and chat_summaries
+
+# Get all tools from the tools module
+tools = get_tools()
+
+@app.post("/chat", response_model=ChatResponse)
+async def handle_chat(chat_message: ChatMessage):
+    session_id = chat_message.session_id
+    
+    # Initialize or retrieve chat session
+    if session_id not in chat_sessions:
+        # Create system prompt with empty summary
+        system_message = """You are an expert longevity assistant specializing in evidence-based health optimization, supplementation, and prescription medications.
+
+## YOUR ROLE:
+- Provide concise, scientifically-grounded advice on supplements, prescription medications, and longevity interventions
+- Focus on personalization based on the user's specific health concerns and goals
+- Maintain a friendly, supportive tone while being direct and efficient
+
+## CONVERSATION FLOW:
+1. Begin by asking clarifying questions about the user's specific health concerns
+2. Once you understand their needs, recommend a focused set of solutions
+3. For supplements or medications, use the get_product_details tool to provide information
+4. If the user expresses interest in prescription products, recommend pre-paying for the product with a consultation
+5. End with a brief encouraging remark related to their health goals
+
+## PRESCRIPTION RECOMMENDATIONS:
+- When a user presents with a health concern, first ask clarifying questions
+- Based on their responses, recommend ONE or at most TWO prescription medications that would be most effective
+- Always clearly state that prescriptions require a medical consultation
+- Emphasize that prescription medications require a consultation with our nurse practitioner (additional fee applies)
+- Include this disclaimer with ANY prescription recommendation: "This medication requires a prescription from our nurse practitioner. Please schedule a consultation (additional fee applies)."
+
+## COMPLEMENTARY APPROACHES:
+- When recommending a prescription medication, briefly mention 2-3 complementary supplements that may support the same health goal
+- Present these as educational information only, not as additional purchase suggestions
+- Use phrases like "Some people also find benefit from..." or "For a holistic approach, you might research..."
+- Do not include purchase links for these complementary supplements unless specifically requested
+
+## PAYMENT HANDLING:
+- When a user expresses interest in purchasing prescription products, ask if they would like to pre-pay with a consultation
+- Generate ONE payment link for the entire purchase using the create_payment_link tool
+- Use the create_payment_link tool with a clear description of products and quantities
+  (e.g., "I want to buy 1 tretinoin and 1 consultation")
+- After generating the payment link, ask for the user's email and phone number
+- Explain that payments will be refunded if the Nurse Practitioner determines the user doesn't meet the criteria
+- If a user requests additional products, ALWAYS check availability using get_available_products or check_product_availability before generating a payment link
+- If a user only wants to purchase a subset of recommended products, generate a payment link only for the products they want to purchase
+
+## PRODUCT RESTRICTIONS:
+- ONLY recommend products available in our catalog
+- Use the get_available_products tool to check which products are available and use the exact names of the products in the catalog
+- DO NOT suggest products not in our catalog
+- Remember that NP_consultation is a valid product in our catalog
+- When a user asks to buy additional products, ALWAYS verify their availability before proceeding
+
+## TOOLS AVAILABLE:
+- For supplements: search_supplements_by_condition, search_supplements_by_name, get_supplement_details, list_all_supplements
+- For prescription drugs: search_prescription_drugs_by_condition, search_prescription_drugs_by_name, get_prescription_drug_details, list_all_prescription_drugs
+- Combined searches: search_all_products_by_condition, search_all_products_by_name, get_product_details, list_all_products
+- Catalog verification: get_available_products
+- Payment: create_payment_link. This tool takes a string describing what products and quantities to purchase in a single transaction
+        (e.g., "I want to buy 1 tretinoin and 1 consultation", "I want to buy 1 finasteride, 1 minoxidil and 1 consultation")
+
+## GUIDELINES:
+- Keep responses under 150 words unless detailed information is requested
+- Use bullet points for clarity when listing multiple recommendations
+- Cite evidence categories (strong, moderate, preliminary) for recommendations
+- If a user asks for a product not in our catalog, politely explain we don't carry it and suggest available alternatives
+- If a user declines prescription options, gracefully recommend supplements or lifestyle changes instead
+
+## TONE:
+- Professional but conversational
+- Evidence-based but accessible
+- Supportive without overpromising
+
+Remember to use the appropriate tool for each query type, and always prioritize user safety and scientific accuracy.
+"""
+        
+        # Create the prompt template
+        prompt = ChatPromptTemplate.from_messages(
+            [
+                ("system", system_message),
+                MessagesPlaceholder(variable_name="chat_history", optional=True),
+                ("human", "{input}"),
+                MessagesPlaceholder(variable_name="agent_scratchpad"),
+            ]
+        )
+        
+        # Initialize LLM and memory
+        llm = ChatOpenAI(temperature=0.2, model="gpt-4o-mini", api_key=api_key)
+        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        
+        # Create the agent
+        agent = create_openai_tools_agent(
+            llm=llm,
+            tools=tools,
+            prompt=prompt
+        )
+        
+        # Create the agent executor
+        agent_executor = AgentExecutor(
+            agent=agent,
+            tools=tools,
+            memory=memory,
+            verbose=True
+        )
+        
+        # Store everything in the session
+        chat_sessions[session_id] = ChatSession(
+            agent_executor=agent_executor,
+            memory=memory
+        )
+    
+    # Get the existing session
+    session = chat_sessions[session_id]
+    
+    # Get response from agent
+    result = await session.agent_executor.ainvoke({"input": chat_message.message})
+    response_text = result["output"]
+    
+    # Extract links from the response
+    links = []
+    
+    # Check for supplements first
+    for supp_id, supp_data in SUPPLEMENTS.items():
+        if supp_id in response_text.lower() or supp_data["name"].lower() in response_text.lower():
+            links.append({
+                "name": supp_data["name"],
+                "url": supp_data["affiliate_link"]
+            })
+    
+    # Check for prescription drugs
+    for drug_id, drug_data in PRESCRIPTION_DRUGS.items():
+        if drug_id in response_text.lower() or drug_data["name"].lower() in response_text.lower():
+            links.append({
+                "name": drug_data["name"] + " (Prescription Required)",
+                "url": drug_data["affiliate_link"]
+            })
+    
+    # Update the summary using the existing LLM
+    summarizer_prompt = """Your role is to summarize the conversation, focusing on the user's medically relevant information, 
+    concerns, and any specific supplement or medication needs or preferences they express. Ensure the summary is concise and captures 
+    the essence of the user's health-related queries and the assistant's advice."""
+    
+    # Get the last exchange
+    last_exchange = f"User: {chat_message.message}\nAssistant: {response_text}"
+    
+    # Update the summary
+    summarizer = ChatOpenAI(temperature=0.2, model="gpt-4o-mini", api_key=api_key)
+    summary_update = summarizer.invoke([
+        SystemMessage(content=summarizer_prompt),
+        HumanMessage(content=last_exchange)
+    ]).content
+    
+    # Update the session summary
+    session.summary = f"{session.summary} {summary_update}".strip()
+    
+    return ChatResponse(
+        response=response_text,
+        links=links
+    )
+
+@app.get("/welcome", response_model=dict)
+async def get_welcome_message():
+    """
+    Returns a welcome message for new users.
+    """
+    return {
+        "welcome_message": """
+Welcome to the Longevity Assistant! 👋
+
+I'm here to help you optimize your health and longevity journey. I can:
+
+• Answer questions about supplements and their benefits\n
+• Recommend products based on your specific health goals\n
+• Provide evidence-based information on longevity practices\n
+
+What health or longevity goal would you like to focus on today?
+        """.strip(),
+        "suggested_questions": [
+
+            "I am having hair loss issues",
+            "I am having issues with my sleep",
+            "I am finding it difficult to lose weight",
+            "I am having memory issues",
+            #"What supplements can help with cognitive function?",
+            #"I'm looking for something to improve my sleep quality",
+            #"What should I take for joint pain?",
+            #"What's the best supplement for energy?",
+            #"What's the best supplement for skin health?"
+        ]
+    }

payments/agent.py

@@ -0,0 +1,120 @@
+import os
+from dotenv import dotenv_values
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import ToolNode
+from langchain_core.tools import tool
+
+import stripe
+import json
+# Load values directly from .env file without setting environment variables
+env_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), '.env')
+env_vars = dotenv_values(env_path)
+
+
+stripe.api_key = env_vars.get("STRIPE_API_KEY")
+#product_name is the name of the product in the payments/products.json file
+def generate_payment_link(product_quantities_str: str) -> str:
+    """Generate a Stripe payment link for specified products.
+    
+    Args:
+        product_quantities_str: String with format "(product_1,k_1),(product_2,k_2),...,(product_n,k_n)" where product_i must match a key in products.json and k_i is the quantity. Example: "(finasteride,1),(NP_consultation,1)"
+    """
+    # Parse the input string
+    product_quantities = []
+    pairs = product_quantities_str.strip().split("),(")
+    
+    for pair in pairs:
+        # Clean up the pair string
+        pair = pair.replace("(", "").replace(")", "")
+        if not pair:
+            continue
+            
+        parts = pair.split(",")
+        if len(parts) != 2:
+            raise ValueError(f"Invalid format in pair: {pair}. Expected 'product,quantity'")
+            
+        product_id, quantity_str = parts
+        try:
+            quantity = int(quantity_str)
+        except ValueError:
+            raise ValueError(f"Quantity must be an integer: {quantity_str}")
+            
+        product_quantities.append((product_id, quantity))
+    
+    # Load the product catalog - adjust path based on script location
+    import os
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    catalog_path = os.path.join(script_dir, "products.json")
+    catalog = json.load(open(catalog_path))
+    
+    # Create line items for the payment link
+    # Use a dictionary to track and combine items with the same price_id
+    price_quantities = {}
+    for product_id, quantity in product_quantities:
+        if product_id not in catalog:
+            raise ValueError(f"Product '{product_id}' not found in catalog")
+        
+        price_id = catalog[product_id]["price_id"]
+        if price_id in price_quantities:
+            price_quantities[price_id] += quantity
+        else:
+            price_quantities[price_id] = quantity
+    
+    # Create line items from the consolidated price_quantities
+    line_items = [
+        {"price": price_id, "quantity": quantity}
+        for price_id, quantity in price_quantities.items()
+    ]
+    
+    # Create the payment link
+    payment_link = stripe.PaymentLink.create(
+        line_items=line_items,
+        phone_number_collection={"enabled": True},
+        after_completion={
+            "type": "hosted_confirmation",
+            "hosted_confirmation": {
+                "custom_message": "Thank you for your order! 🎉.\n A nurse practitioner will review your order and contact you shortly."
+            }
+        }
+    )
+    
+    return payment_link.url
+
+
+def process_purchase_request(user_input):
+    """
+    Process a purchase request from a user input string.
+    
+    Args:
+        user_input (str): A string containing purchase intent like 
+                         "I want to buy 3 items of product_i and 2 of product_k"
+    
+    Returns:
+        dict: The response from the tool node containing payment information
+    """
+    # Use the API key directly from the loaded .env values
+    llm = ChatOpenAI(model='gpt-4o-mini', api_key=env_vars.get("OPENAI_API_KEY"), temperature=0)
+
+    # Tool creation
+    tools = [generate_payment_link]
+    tool_node = ToolNode(tools)
+
+    # Tool binding
+    model_with_tools = llm.bind_tools(tools)
+    # Get the LLM to understand the request and format it for tool calling
+    llm_response = model_with_tools.invoke(user_input)
+    print(llm_response)
+    # Pass the LLM's response to the tool node for execution
+    tool_response = tool_node.invoke({"messages": [llm_response]})
+    print(tool_response)
+    return tool_response
+
+# Example usage
+if __name__ == "__main__":
+    sample_request = '1 Finasteride consultation, 1 Minoxidil consultation'
+    result = process_purchase_request(sample_request)
+    print(result)
+    
+    # You can test with other examples
+    # result2 = process_purchase_request("I want to buy 3 items of product_i and 2 of product_k")
+    # print(result2)

payments/create_price.py

@@ -0,0 +1,19 @@
+import stripe
+stripe.api_key = "sk_test_51QzLWD2MnbfibIToo1GmNncuEXXHn0qS8JZ1FMQNB1CWbUuTUt1XP3Q4Plv3imagCoOMtQVmWgc8vHPXGemAdZa900k20pOvcM"
+
+item = stripe.Product.create(
+  name="newTestItem",
+  description="$12/Month subscription",
+  default_price_data={
+    "unit_amount": 1000,
+    "currency": "usd",
+  },
+  expand=["default_price"]
+)
+
+
+
+# Save these identifiers
+print(f"Success! Here is your starter subscription product id: {item.id}")
+print(f"Success! Here is your starter subscription price id: {item.default_price.id}")
+#print(f"Success! Here is your starter subscription price id: {item_price.id}")

payments/payment_tools.py

@@ -0,0 +1,135 @@
+import os
+import json
+import stripe
+from typing import List, Tuple
+
+def parse_product_quantities(product_quantities_str: str) -> List[Tuple[str, int]]:
+    """Parse a product quantities string into a list of (product_id, quantity) tuples.
+    
+    Args:
+        product_quantities_str: String with format "(product_1,k_1),(product_2,k_2),...,(product_n,k_n)"
+            where product_i must match a key in products.json and k_i is the quantity.
+            Example: "(finasteride,1),(NP_consultation,1)"
+    
+    Returns:
+        List of tuples containing (product_id, quantity)
+    
+    Raises:
+        ValueError: If the input string format is invalid
+    """
+    product_quantities = []
+    pairs = product_quantities_str.strip().split("),(")
+    
+    for pair in pairs:
+        # Clean up the pair string
+        pair = pair.replace("(", "").replace(")", "")
+        if not pair:
+            continue
+            
+        parts = pair.split(",")
+        if len(parts) != 2:
+            raise ValueError(f"Invalid format in pair: {pair}. Expected 'product,quantity'")
+            
+        product_id, quantity_str = parts
+        try:
+            quantity = int(quantity_str)
+        except ValueError:
+            raise ValueError(f"Quantity must be an integer: {quantity_str}")
+            
+        product_quantities.append((product_id, quantity))
+    
+    return product_quantities
+
+def generate_payment_link(product_quantities_str: str) -> str:
+    """Generate a Stripe payment link for specified products.
+    
+    Args:
+        product_quantities_str: String describing products and quantities
+            Format: "(product_1,k_1),(product_2,k_2),...,(product_n,k_n)"
+            Example: "(finasteride,1),(NP_consultation,1)"
+    
+    Returns:
+        Stripe payment link URL
+    
+    Raises:
+        ValueError: If products are not found or quantities are invalid
+        stripe.error.StripeError: If there's an error with the Stripe API
+    """
+    try:
+        # Parse the product quantities
+        product_quantities = parse_product_quantities(product_quantities_str)
+        
+        # Load the product catalog
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        catalog_path = os.path.join(script_dir, "products.json")
+        
+        try:
+            with open(catalog_path, 'r') as f:
+                catalog = json.load(f)
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            raise ValueError(f"Error loading product catalog: {str(e)}")
+        
+        # Create line items for the payment link
+        price_quantities = {}
+        for product_id, quantity in product_quantities:
+            if product_id not in catalog:
+                raise ValueError(f"Product '{product_id}' not found in catalog")
+            
+            price_id = catalog[product_id]["price_id"]
+            price_quantities[price_id] = price_quantities.get(price_id, 0) + quantity
+        
+        # Create line items from the consolidated price_quantities
+        line_items = [
+            {"price": price_id, "quantity": quantity}
+            for price_id, quantity in price_quantities.items()
+        ]
+        
+        # Create the payment link
+        payment_link = stripe.PaymentLink.create(
+            line_items=line_items,
+            phone_number_collection={"enabled": True},
+            after_completion={
+                "type": "hosted_confirmation",
+                "hosted_confirmation": {
+                    "custom_message": "Thank you for your order! 🎉\nA nurse practitioner will review your order and contact you shortly."
+                }
+            }
+        )
+        
+        return payment_link.url
+        
+    except stripe.error.StripeError as e:
+        raise ValueError(f"Stripe API error: {str(e)}")
+
+def create_non_recurring_item_with_price(product_name: str, price: int, description: str = "Default description") -> stripe.Product:
+    """Create a new Stripe product with a non-recurring price.
+    
+    Args:
+        product_name: Name of the product
+        price: Price in cents
+        description: Product description
+    
+    Returns:
+        Stripe Product object
+    
+    Raises:
+        stripe.error.StripeError: If there's an error with the Stripe API
+    """
+    try:
+        item = stripe.Product.create(
+            name=product_name,
+            description=description,
+            default_price_data={
+                "unit_amount": price,
+                "currency": "usd",
+            },
+            expand=["default_price"]
+        )
+        
+        print(f"Created product with id: {item.id}")
+        print(f"Created price with id: {item.default_price.id}")
+        
+        return item
+        
+    except stripe.error.StripeError as e:
+        raise ValueError(f"Error creating Stripe product: {str(e)}")

payments/products.json

@@ -0,0 +1,82 @@
+{
+    "NP_consultation": {
+        "product_id": "prod_Rt9PWRucM6Wadt",
+        "price_id": "price_1QzN752MnbfibITojfGIs66e"
+    },
+    "finasteride": {
+        "product_id": "prod_Rt9Qwj9pJN7j4c",
+        "price_id": "price_1QzN842MnbfibIToWvjmIgYg"
+    },
+    "tretinoin": {
+        "product_id": "prod_RvI4MdmYKy0bL3",
+        "price_id": "price_1R1RU52MnbfibIToeUUQXMIZ"
+    },
+    "metformin": {
+        "product_id": "prod_RvI43hy7caoRpD",
+        "price_id": "price_1R1RU52MnbfibIToRjvABsFs"
+    },
+    "semaglutide": {
+        "product_id": "prod_RvI4MY1TSllOQe",
+        "price_id": "price_1R1RU52MnbfibIToq1zatJNe"
+    },
+    "minoxidil": {
+        "product_id": "prod_RvI4ZwJmyr6ORy",
+        "price_id": "price_1R1RTy2MnbfibITov5hHr6bb"
+    },
+    "berberine": {
+        "product_id": "prod_RvI48b6paTkrvD",
+        "price_id": "price_1R1RTy2MnbfibIToriPHZWQJ"
+    },
+    "uber minoxidil": {
+        "product_id": "prod_RvI4jg0L500y6V",
+        "price_id": "price_1R1RTz2MnbfibIToEO7cIrXS"
+    },
+    "biotin": {
+        "product_id": "prod_RvI4dlIslPSgVA",
+        "price_id": "price_1R1RTz2MnbfibIToerYafEud"
+    },
+    "protein": {
+        "product_id": "prod_RvI4aIcp3Tt4sB",
+        "price_id": "price_1R1RU02MnbfibIToH4TGN4wd"
+    },
+    "creatine": {
+        "product_id": "prod_RvI4jJV2ga5kCU",
+        "price_id": "price_1R1RU02MnbfibITomNTvzECN"
+    },
+    "vitamin_c": {
+        "product_id": "prod_RvI4L8EV1gDFxl",
+        "price_id": "price_1R1RU12MnbfibITozq17jxTw"
+    },
+    "omega_3": {
+        "product_id": "prod_RvI4tUkYisZgIi",
+        "price_id": "price_1R1RU12MnbfibITo0YJFeuJT"
+    },
+    "vitamin_d": {
+        "product_id": "prod_RvI4qDpZsYAgGf",
+        "price_id": "price_1R1RU12MnbfibITofaWnibCd"
+    },
+    "magnesium": {
+        "product_id": "prod_RvI4fWkWSE04e4",
+        "price_id": "price_1R1RU22MnbfibITogOteYaYi"
+    },
+    "zinc": {
+        "product_id": "prod_RvI4AotK9kH2v9",
+        "price_id": "price_1R1RU32MnbfibITozho1pSua"
+    },
+    "ashwagandha": {
+        "product_id": "prod_RvI4zrDFVPKp4I",
+        "price_id": "price_1R1RU32MnbfibITo8ICxb94X"
+    },
+    "lions_mane": {
+        "product_id": "prod_RvI4KkOiQIxaey",
+        "price_id": "price_1R1RU32MnbfibIToPKuTKQXv"
+    },
+    "nac": {
+        "product_id": "prod_RvI4YVD1c9l136",
+        "price_id": "price_1R1RU42MnbfibITo4eApTmet"
+    },
+    "minoxidil_prescription": {
+        "product_id": "prod_RvI4Xp1CM2qCSs",
+        "price_id": "price_1R1RU42MnbfibIToU0k8SWlF"
+    }
+}

payments/test_payment_link.py

@@ -0,0 +1,51 @@
+import payment_tools as payment_tools
+
+# Example 1: Single product
+print("Example 1: Single finasteride product")
+link = payment_tools.generate_payment_link("(finasteride,1)")
+print(f"Payment link: {link}\n")
+
+# Example 2: Multiple products
+print("Example 2: Finasteride and consultation")
+link = payment_tools.generate_payment_link("(finasteride,1),(NP_consultation,1)")
+print(f"Payment link: {link}\n")
+
+# Example 3: Hair loss combo
+print("Example 3: Hair loss combo")
+link = payment_tools.generate_payment_link("(finasteride,1),(minoxidil,2),(biotin,1)")
+print(f"Payment link: {link}\n")
+
+# Example 4: Weight management combo
+print("Example 4: Weight management combo")
+link = payment_tools.generate_payment_link("(metformin,1),(semaglutide,1),(berberine,2)")
+print(f"Payment link: {link}\n")
+
+# Example 5: Supplement stack
+print("Example 5: Supplement stack")
+link = payment_tools.generate_payment_link("(vitamin_d,1),(omega_3,1),(magnesium,1),(zinc,1)")
+print(f"Payment link: {link}\n")
+
+# Example 6: Cognitive enhancement
+print("Example 6: Cognitive enhancement")
+link = payment_tools.generate_payment_link("(lions_mane,2),(ashwagandha,1),(nac,1)")
+print(f"Payment link: {link}\n")
+
+# Example 7: Fitness stack
+print("Example 7: Fitness stack")
+link = payment_tools.generate_payment_link("(protein,2),(creatine,1)")
+print(f"Payment link: {link}\n")
+
+# Example 8: Premium hair treatment
+print("Example 8: Premium hair treatment")
+link = payment_tools.generate_payment_link("(uber minoxidil,1),(finasteride,1),(biotin,2),(NP_consultation,1)")
+print(f"Payment link: {link}\n")
+
+# Example 9: Multiple quantities
+print("Example 9: Multiple quantities")
+link = payment_tools.generate_payment_link("(vitamin_c,3),(vitamin_d,2),(zinc,2)")
+print(f"Payment link: {link}\n")
+
+# Example 10: Complete wellness package
+print("Example 10: Complete wellness package")
+link = payment_tools.generate_payment_link("(NP_consultation,1),(vitamin_d,1),(omega_3,1),(magnesium,1),(zinc,1),(protein,1),(creatine,1)")
+print(f"Payment link: {link}\n")

render_app.py

@@ -0,0 +1,183 @@
+import os
+import streamlit as st
+import requests
+import uuid
+import time
+from datetime import datetime, timedelta
+
+# Get the API URL from environment variable
+API_URL = os.getenv('API_URL')
+
+if not API_URL:
+    st.error("API_URL environment variable is not set. Please configure the API URL.")
+    st.stop()
+
+# Set session timeout to 15 minutes
+SESSION_TIMEOUT = 15 * 60  # 15 minutes in seconds
+# Set API request timeout to 2 minutes for Render (cold starts can be slow)
+API_TIMEOUT = 120  # seconds
+
+st.title("Longevity Assistant")
+
+# Initialize session state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.last_activity = datetime.now()
+    
+    # Get welcome message from API
+    try:
+        with st.spinner("Connecting to server..."):
+            welcome_response = requests.get(f"{API_URL}/welcome", timeout=API_TIMEOUT)
+            if welcome_response.status_code == 200:
+                welcome_data = welcome_response.json()
+                
+                # Add assistant welcome message to chat history
+                st.session_state.messages.append({
+                    "role": "assistant", 
+                    "content": welcome_data["welcome_message"],
+                    "links": []
+                })
+                
+                # Store suggested questions
+                st.session_state.suggested_questions = welcome_data.get("suggested_questions", [])
+            else:
+                raise Exception(f"Server returned status code: {welcome_response.status_code}")
+    except requests.Timeout:
+        st.error("Server is taking too long to respond. This might be due to a cold start. Please refresh the page.")
+        st.session_state.messages.append({
+            "role": "assistant", 
+            "content": "The server is warming up. Please wait a moment and refresh the page.",
+            "links": []
+        })
+        st.session_state.suggested_questions = []
+    except Exception as e:
+        st.error(f"Error connecting to the server: {str(e)}")
+        st.session_state.messages.append({
+            "role": "assistant", 
+            "content": "Welcome to the Longevity Assistant! How can I help you today?",
+            "links": []
+        })
+        st.session_state.suggested_questions = []
+
+elif "last_activity" in st.session_state:
+    # Check if session has expired
+    time_inactive = (datetime.now() - st.session_state.last_activity).total_seconds()
+    if time_inactive > SESSION_TIMEOUT:
+        # Reset session
+        st.session_state.messages = []
+        st.session_state.session_id = str(uuid.uuid4())
+    
+    # Update last activity time
+    st.session_state.last_activity = datetime.now()
+
+# Display chat messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.write(message["content"])
+        if "links" in message and message["links"]:
+            for link in message["links"]:
+                st.markdown(f"[{link['name']}]({link['url']})")
+
+# Display suggested questions as buttons (only if no messages from user yet)
+if len(st.session_state.messages) == 1 and hasattr(st.session_state, 'suggested_questions'):
+    st.write("Try asking about:")
+    cols = st.columns(2)
+    for i, question in enumerate(st.session_state.suggested_questions):
+        with cols[i % 2]:
+            if st.button(question, key=f"suggested_{i}"):
+                # Add user message to chat history
+                st.session_state.messages.append({"role": "user", "content": question})
+                
+                # Display user message immediately
+                with st.chat_message("user"):
+                    st.write(question)
+                
+                # Process the question (reusing the chat input logic)
+                with st.chat_message("assistant"):
+                    with st.spinner("Thinking..."):
+                        try:
+                            response = requests.post(
+                                f"{API_URL}/chat",
+                                json={"session_id": st.session_state.session_id, "message": question},
+                                timeout=API_TIMEOUT
+                            )
+                            
+                            if response.status_code == 200:
+                                response_data = response.json()
+                                # Store response for history
+                                st.session_state.messages.append({
+                                    "role": "assistant",
+                                    "content": response_data["response"],
+                                    "links": response_data["links"]
+                                })
+                                # Display the response
+                                st.write(response_data["response"])
+                                if response_data["links"]:
+                                    for link in response_data["links"]:
+                                        st.markdown(f"[{link['name']}]({link['url']})")
+                            else:
+                                st.error(f"Error: {response.status_code}")
+                                st.session_state.messages.append({
+                                    "role": "assistant",
+                                    "content": "Sorry, I encountered an error while processing your request.",
+                                    "links": []
+                                })
+                        except Exception as e:
+                            st.error(f"Error connecting to the server: {str(e)}")
+                            st.session_state.messages.append({
+                                "role": "assistant",
+                                "content": "Sorry, I'm having trouble connecting to the server.",
+                                "links": []
+                            })
+                
+                # Force a rerun to update the UI
+                st.rerun()
+
+# Chat input
+if prompt := st.chat_input():
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    # Display user message immediately
+    with st.chat_message("user"):
+        st.write(prompt)
+    
+    # Display assistant "thinking" message with spinner
+    with st.chat_message("assistant"):
+        with st.spinner("Thinking..."):
+            # Get bot response
+            try:
+                response = requests.post(
+                    f"{API_URL}/chat",
+                    json={"session_id": st.session_state.session_id, "message": prompt},
+                    timeout=API_TIMEOUT
+                )
+                
+                if response.status_code == 200:
+                    response_data = response.json()
+                    # Store response for history
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": response_data["response"],
+                        "links": response_data["links"]
+                    })
+                    # Display the response
+                    st.write(response_data["response"])
+                    if response_data["links"]:
+                        for link in response_data["links"]:
+                            st.markdown(f"[{link['name']}]({link['url']})")
+                else:
+                    st.error(f"Error: {response.status_code}")
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": "Sorry, I encountered an error while processing your request.",
+                        "links": []
+                    })
+            except Exception as e:
+                st.error(f"Error connecting to the server: {str(e)}")
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": "Sorry, I'm having trouble connecting to the server.",
+                    "links": []
+                }) 

tools.py

@@ -0,0 +1,396 @@
+from typing import List, Dict, Optional
+from langchain.tools import StructuredTool
+import json
+# Now import from payments module
+from src.payments.agent import process_purchase_request
+# Load datasets
+with open("data/supplements.json", "r") as f:
+    SUPPLEMENTS = json.load(f)
+
+with open("data/prescription_drugs.json", "r") as f:
+    PRESCRIPTION_DRUGS = json.load(f)
+
+# Combine both datasets for unified searching
+ALL_PRODUCTS = {**SUPPLEMENTS, **PRESCRIPTION_DRUGS}
+
+# Supplement search and retrieval functions
+def search_supplements_by_condition(query: str) -> List[Dict]:
+    """
+    Search for supplements that are recommended for a specific health condition,
+    well-being goal, or enhancement purpose.
+    
+    Args:
+        query: The condition, goal, or purpose to search supplements for 
+        (e.g., 'hair_loss', 'cognitive_function', 'muscle_growth')
+    
+    Returns:
+        A list of supplements that match the query
+    """
+    matching_supplements = []
+    query = query.lower()
+    
+    for supp_id, supp_data in SUPPLEMENTS.items():
+        # Check conditions
+        conditions = [c.lower() for c in supp_data.get("conditions", [])]
+        # Check benefits/enhancements
+        benefits = [b.lower() for b in supp_data.get("benefits", [])]
+        # Check categories
+        categories = [cat.lower() for cat in supp_data.get("categories", [])]
+        
+        # Match against all fields
+        if (query in conditions or 
+            query in benefits or 
+            query in categories or 
+            query in supp_data["name"].lower() or 
+            query in supp_data["description"].lower()):
+            
+            matching_supplements.append({
+                "id": supp_id,
+                "name": supp_data["name"],
+                "description": supp_data["description"],
+                "link": supp_data["affiliate_link"],
+                "conditions": supp_data.get("conditions", []),
+                "benefits": supp_data.get("benefits", []),
+                "categories": supp_data.get("categories", []),
+                "disclaimers": supp_data.get("disclaimers", [])
+            })
+    
+    return matching_supplements
+
+def search_supplements_by_name(name: str) -> Optional[Dict]:
+    """
+    Search for a supplement by its name.
+    
+    Args:
+        name: The name of the supplement to search for (e.g., 'Vitamin D3', 'Magnesium')
+    
+    Returns:
+        Details of the supplement if found, None otherwise
+    """
+    name = name.lower()
+    for supp_id, supp_data in SUPPLEMENTS.items():
+        if name in supp_data["name"].lower():
+            return {
+                "id": supp_id,
+                "name": supp_data["name"],
+                "description": supp_data["description"],
+                "link": supp_data["affiliate_link"],
+                "conditions": supp_data.get("conditions", []),
+                "benefits": supp_data.get("benefits", []),
+                "categories": supp_data.get("categories", []),
+                "disclaimers": supp_data.get("disclaimers", [])
+            }
+    return None
+
+def get_supplement_details(supplement_id: str) -> Optional[Dict]:
+    """
+    Get detailed information about a specific supplement.
+    
+    Args:
+        supplement_id: The ID of the supplement to retrieve
+    
+    Returns:
+        Detailed information about the supplement or None if not found
+    """
+    if supplement_id in SUPPLEMENTS:
+        supp_data = SUPPLEMENTS[supplement_id]
+        return {
+            "id": supplement_id,
+            "name": supp_data["name"],
+            "description": supp_data["description"],
+            "link": supp_data["affiliate_link"],
+            "conditions": supp_data.get("conditions", []),
+            "disclaimers": supp_data.get("disclaimers", [])
+        }
+    return None
+
+def list_all_supplements() -> List[Dict]:
+    """
+    List all available supplements in the database.
+    
+    Returns:
+        A list of all supplements with their basic information
+    """
+    return [
+        {
+            "id": supp_id,
+            "name": supp_data["name"],
+            "description": supp_data["description"],
+            "conditions": supp_data.get("conditions", [])
+        }
+        for supp_id, supp_data in SUPPLEMENTS.items()
+    ]
+
+# Prescription drug search and retrieval functions
+def search_prescription_drugs_by_condition(query: str) -> List[Dict]:
+    """
+    Search for prescription drugs that are used for a specific health condition,
+    well-being goal, or therapeutic purpose.
+    
+    Args:
+        query: The condition, goal, or purpose to search drugs for 
+        (e.g., 'hypertension', 'depression', 'hair_loss')
+    
+    Returns:
+        A list of prescription drugs that match the query
+    """
+    matching_drugs = []
+    query = query.lower()
+    
+    for drug_id, drug_data in PRESCRIPTION_DRUGS.items():
+        # Check conditions
+        conditions = [c.lower() for c in drug_data.get("conditions", [])]
+        # Check benefits
+        benefits = [b.lower() for b in drug_data.get("benefits", [])]
+        # Check categories
+        categories = [cat.lower() for cat in drug_data.get("categories", [])]
+        
+        # Match against all fields
+        if (query in conditions or 
+            query in benefits or 
+            query in categories or 
+            query in drug_data["name"].lower() or 
+            query in drug_data["description"].lower()):
+            
+            matching_drugs.append({
+                "id": drug_id,
+                "name": drug_data["name"],
+                "description": drug_data["description"],
+                "link": drug_data["affiliate_link"],
+                "conditions": drug_data.get("conditions", []),
+                "benefits": drug_data.get("benefits", []),
+                "categories": drug_data.get("categories", []),
+                "disclaimers": drug_data.get("disclaimers", []),
+                "requires_prescription": True
+            })
+    
+    return matching_drugs
+
+def search_prescription_drugs_by_name(name: str) -> Optional[Dict]:
+    """
+    Search for a prescription drug by its name.
+    
+    Args:
+        name: The name of the drug to search for (e.g., 'Metformin', 'Atorvastatin')
+    
+    Returns:
+        Details of the prescription drug if found, None otherwise
+    """
+    name = name.lower()
+    for drug_id, drug_data in PRESCRIPTION_DRUGS.items():
+        if name in drug_data["name"].lower():
+            return {
+                "id": drug_id,
+                "name": drug_data["name"],
+                "description": drug_data["description"],
+                "link": drug_data["affiliate_link"],
+                "conditions": drug_data.get("conditions", []),
+                "benefits": drug_data.get("benefits", []),
+                "categories": drug_data.get("categories", []),
+                "disclaimers": drug_data.get("disclaimers", []),
+                "requires_prescription": True
+            }
+    return None
+
+def get_prescription_drug_details(drug_id: str) -> Optional[Dict]:
+    """
+    Get detailed information about a specific prescription drug.
+    
+    Args:
+        drug_id: The ID of the prescription drug to retrieve
+    
+    Returns:
+        Detailed information about the drug or None if not found
+    """
+    if drug_id in PRESCRIPTION_DRUGS:
+        drug_data = PRESCRIPTION_DRUGS[drug_id]
+        return {
+            "id": drug_id,
+            "name": drug_data["name"],
+            "description": drug_data["description"],
+            "link": drug_data["affiliate_link"],
+            "conditions": drug_data.get("conditions", []),
+            "benefits": drug_data.get("benefits", []),
+            "categories": drug_data.get("categories", []),
+            "disclaimers": drug_data.get("disclaimers", []),
+            "requires_prescription": True
+        }
+    return None
+
+def list_all_prescription_drugs() -> List[Dict]:
+    """
+    List all available prescription drugs in the database.
+    
+    Returns:
+        A list of all prescription drugs with their basic information
+    """
+    return [
+        {
+            "id": drug_id,
+            "name": drug_data["name"],
+            "description": drug_data["description"],
+            "conditions": drug_data.get("conditions", []),
+            "requires_prescription": True
+        }
+        for drug_id, drug_data in PRESCRIPTION_DRUGS.items()
+    ]
+
+# Combined search functions
+def search_all_products_by_condition(query: str) -> List[Dict]:
+    """
+    Search for both supplements and prescription drugs that are recommended for a specific health condition,
+    well-being goal, or enhancement purpose.
+    
+    Args:
+        query: The condition, goal, or purpose to search for
+        (e.g., 'hair_loss', 'cognitive_function', 'depression')
+    
+    Returns:
+        A list of supplements and prescription drugs that match the query
+    """
+    supplements = search_supplements_by_condition(query)
+    prescription_drugs = search_prescription_drugs_by_condition(query)
+    
+    return supplements + prescription_drugs
+
+def search_all_products_by_name(name: str) -> List[Dict]:
+    """
+    Search for both supplements and prescription drugs by name.
+    
+    Args:
+        name: The name to search for (e.g., 'Vitamin D3', 'Metformin')
+    
+    Returns:
+        List of products matching the name query
+    """
+    results = []
+    
+    supplement = search_supplements_by_name(name)
+    if supplement:
+        results.append(supplement)
+        
+    prescription = search_prescription_drugs_by_name(name)
+    if prescription:
+        results.append(prescription)
+        
+    return results
+
+def get_product_details(product_id: str) -> Optional[Dict]:
+    """
+    Get detailed information about a specific product (supplement or prescription drug).
+    
+    Args:
+        product_id: The ID of the product to retrieve
+    
+    Returns:
+        Detailed information about the product or None if not found
+    """
+    supplement = get_supplement_details(product_id)
+    if supplement:
+        return supplement
+        
+    prescription = get_prescription_drug_details(product_id)
+    if prescription:
+        return prescription
+        
+    return None
+
+def list_all_products() -> List[Dict]:
+    """
+    List all available products (supplements and prescription drugs) in the database.
+    
+    Returns:
+        A list of all products with their basic information
+    """
+    supplements = list_all_supplements()
+    prescription_drugs = list_all_prescription_drugs()
+    
+    return supplements + prescription_drugs
+
+def create_payment_link(request: str) -> str:
+    """
+    Create a payment link for products and consultations based on a natural language request.
+    
+    Args:
+        request: A string describing what products and quantities to purchase
+        (e.g., "I want to buy 1 tretinoin and 1 consultation")
+    
+    Returns:
+        The payment link URL
+    """
+    
+    # Process the request and get payment link
+    response = process_purchase_request(request)
+    #response['messages'][0].content
+    return response
+
+# Create and export Langchain tools
+def get_tools():
+    """Return all the tools needed for the agent"""
+    return [
+        StructuredTool.from_function(search_supplements_by_condition),
+        StructuredTool.from_function(search_prescription_drugs_by_condition),
+        StructuredTool.from_function(search_all_products_by_condition),
+        StructuredTool.from_function(search_supplements_by_name),
+        StructuredTool.from_function(search_prescription_drugs_by_name),
+        StructuredTool.from_function(search_all_products_by_name),
+        StructuredTool.from_function(get_supplement_details),
+        StructuredTool.from_function(get_prescription_drug_details),
+        StructuredTool.from_function(get_product_details),
+        StructuredTool.from_function(list_all_supplements),
+        StructuredTool.from_function(list_all_prescription_drugs),
+        StructuredTool.from_function(list_all_products),
+        StructuredTool.from_function(create_payment_link)
+    ]
+
+# Export data for use in main.py
+def get_supplements():
+    return SUPPLEMENTS
+
+def get_prescription_drugs():
+    return PRESCRIPTION_DRUGS 
+
+
+def get_available_products() -> Dict:
+    """
+    Get a list of all available products in the catalog.
+    
+    Returns:
+        A dictionary containing available products categorized by type
+    """
+    # Load the products catalog
+    with open("src/payments/products.json", "r") as f:
+        products_catalog = json.load(f)
+    
+    # Separate into supplements, prescription drugs, and services
+    supplements = []
+    prescription_drugs = []
+    services = []
+    
+    for product_id in products_catalog.keys():
+        if product_id == "NP_consultation":
+            services.append(product_id)  # Add consultation as a service
+        elif product_id in PRESCRIPTION_DRUGS:
+            prescription_drugs.append(product_id)
+        elif product_id in SUPPLEMENTS:
+            supplements.append(product_id)
+    
+    return {
+        "supplements": supplements,
+        "prescription_drugs": prescription_drugs,
+        "services": services,
+        "all_products": list(products_catalog.keys())
+    }
+
+if __name__ == "__main__":
+    sample_request = '1 Finasteride consultation, 1 Minoxidil consultation'
+    result = process_purchase_request(sample_request)
+    print(result)
+    
+    breakpoint()
+
+    asd = 1
+    # You can test with other examples
+    # result2 = process_purchase_request("I want to buy 3 items of product_i and 2 of product_k")
+    # print(result2)
+