# hello world import os # https://stackoverflow.com/questions/76175046/how-to-add-prompt-to-langchain-conversationalretrievalchain-chat-over-docs-with # again from: # https://python.langchain.com/docs/integrations/providers/vectara/vectara_chat from langchain.document_loaders import PyPDFDirectoryLoader import pandas as pd import langchain from queue import Queue from typing import Any from langchain.llms.huggingface_text_gen_inference import HuggingFaceTextGenInference from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler from langchain.schema import LLMResult from langchain.embeddings import HuggingFaceEmbeddings from langchain.vectorstores import FAISS from langchain.prompts.prompt import PromptTemplate from anyio.from_thread import start_blocking_portal #For model callback streaming from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate, ChatPromptTemplate import os from dotenv import load_dotenv import streamlit as st import json from langchain.document_loaders import PyPDFLoader from langchain.text_splitter import CharacterTextSplitter from langchain.embeddings import OpenAIEmbeddings from langchain.chains.question_answering import load_qa_chain from langchain.chat_models import ChatOpenAI # from langchain.chat_models import ChatAnthropic from langchain_anthropic import ChatAnthropic from langchain.vectorstores import Chroma import chromadb from langchain.text_splitter import RecursiveCharacterTextSplitter from langchain.llms import OpenAI from langchain.chains import RetrievalQA from langchain.document_loaders import TextLoader from langchain.document_loaders import DirectoryLoader from langchain_community.document_loaders import PyMuPDFLoader from langchain.schema import Document from langchain.memory import ConversationBufferMemory from langchain.chains.conversational_retrieval.prompts import CONDENSE_QUESTION_PROMPT from langchain.chains.conversational_retrieval.prompts import QA_PROMPT import gradio as gr from langchain.memory import ConversationBufferMemory from langchain.chains import ConversationalRetrievalChain from langchain.chains import ConversationChain from langchain.prompts import PromptTemplate from langchain.chains import LLMChain print("Started") # Function to map UI region selection to DB metadata region # def get_db_region(ui_region: str) -> str: # """Maps UI region selection (e.g., 'Iowa') to the region string stored in metadata (e.g., 'United States').""" # if ui_region == "Iowa": # return "United States" # # Add more mappings if needed (e.g., Africa) # return ui_region # Default to using the UI string if no specific mapping def get_species_list_from_db(db_name): embedding = OpenAIEmbeddings() vectordb_temp = Chroma(persist_directory=db_name, embedding_function=embedding) species_list=[] for meta in vectordb_temp.get()["metadatas"] : try: matched_first_species = meta['matched_specie_0'] except KeyError: continue # Since each document is considered as a single chunk, the chunk_index is 0 for all species_list.append( matched_first_species) return species_list # default_persist_directory = './db5' # For deployement default_persist_directory='./vector-databases-deployed/db5-agllm-data-isu-field-insects-all-species' species_list=get_species_list_from_db(default_persist_directory) # default_persist_directory = 'vector-databases/db5-pre-completion' # For Development csv_filepath1 = "./agllm-data/corrected/Corrected_supplemented-insect_data-2500-sorted.xlsx" csv_filepath2 = "./agllm-data/corrected/Corrected_supplemented-insect_data-remaining.xlsx" # India data cv_india="./agllm-data/india/species.csv" model_name=4 max_tokens=400 system_message = {"role": "system", "content": "You are a helpful assistant."} # TODO: double check how this plays out later. langchain.debug=False # TODO: DOUBLE CHECK from langchain import globals globals.set_debug(False) retriever_k_value=3 embedding = OpenAIEmbeddings() print("Started....") class ChatOpenRouter(ChatOpenAI): openai_api_base: str openai_api_key: str model_name: str def __init__(self, model_name: str, openai_api_key: [str] = None, openai_api_base: str = "https://openrouter.ai/api/v1", **kwargs): openai_api_key = openai_api_key or os.getenv('OPENROUTER_API_KEY') super().__init__(openai_api_base=openai_api_base, openai_api_key=openai_api_key, model_name=model_name, **kwargs) ######### todo: skipping the first step # print(# Single example # vectordb.as_retriever(k=2, search_kwargs={"filter": {"matched_specie_0": "Hypagyrtis unipunctata"}, 'k':1}).get_relevant_documents( # "Checking if retriever is correctly initalized?" # )) columns = ['species', 'common name', 'order', 'family', 'genus', 'Updated role in ecosystem', 'Proof', 'ipm strategies', 'size of insect', 'geographical spread', 'life cycle specifics', 'pest for plant species', 'species status', 'distribution area', 'appearance', 'identification'] df1 = pd.read_excel(csv_filepath1, usecols=columns) df2 = pd.read_excel(csv_filepath2, usecols=columns) df_india = pd.read_csv(cv_india) all_insects_data = pd.concat([df1, df2], ignore_index=True) def get_prompt_with_vetted_info_from_specie_name(search_for_specie, mode): def read_and_format_filtered_csv_better(dataframe_given, insect_specie): filtered_data = dataframe_given[dataframe_given['species'] == insect_specie] formatted_data = "" # Format the filtered data for index, row in filtered_data.iterrows(): row_data = [f"{col}: {row[col]}" for col in filtered_data.columns] formatted_row = "\n".join(row_data) formatted_data += f"{formatted_row}\n" return formatted_data # Use the path to your CSV file here vetted_info=read_and_format_filtered_csv_better(all_insects_data, search_for_specie) india_info=read_and_format_filtered_csv_better(df_india, search_for_specie) if mode=="Farmer": language_constraint="The language should be acustomed to the Farmers. Given question is likely to be asked by a farmer in the field will ask which will help to make decisions which are immediate and practical." elif mode=="Researcher": language_constraint="The language should be acustomed to a researcher. Given question is likely to be asked by a scientist which are comprehensive and aimed at exploring new knowledge or refining existing methodologies" else: print("No valid mode provided. Exiting") exit() # general_system_template = """ # In every question you are provided information about the insect/weed. Two types of information are: First, Vetted Information (which is same in every questinon) and Second, some context from external documents about an insect/weed species and a question by the user. answer the question according to these two types of informations. # ---- # Vetted info is as follows: # {vetted_info} # ---- # The context retrieved for documents about this particular question is as follows: # {context} # ---- # Additional Instruction: # 1. Reference Constraint # At the end of each answer provide the source/reference for the given data in following format: # \n\n[enter two new lines before writing below] References: # Vetted Information Used: Write what was used from the document for coming up with the answer above. Write exact part of lines. If nothing, write 'Nothing'. # Documents Used: Write what was used from the document for coming up with the answer above. If nothing, write 'Nothing'. Write exact part of lines and document used. # 2. Information Constraint: # Only answer the question from information provided otherwise say you dont know. You have to answer in 50 words including references. Prioritize information in documents/context over vetted information. And first mention the warnings/things to be careful about. # 3. Language constraint: # {language_constraint} # ---- # """.format(vetted_info=vetted_info, language_constraint=language_constraint,context="{context}", ) general_system_template = f""" You are an AI assistant specialized in providing information about insects/weeds. Answer the user's question based on the available information or your general knowledge. The context retrieved for this question is as follows: {{context}} Instructions: 1. Evaluate the relevance of the provided context to the question. 2. If the context contains relevant information, use it to answer the question and explicitly mention "Based on provided information" in your source. 3. If the context does not contain relevant information, use your general knowledge to answer the question and state "Based on general knowledge" as the source. 4. Format your response as follows: Answer: Provide a concise answer in less than 50 words. Source: State either "Based on provided information" or "Based on general knowledge". 5. Language constraint: {language_constraint} 6. Other region (India) information: {india_info} 7. So you have two kinds of information (default from Iowa and other region (India) information). First need to ask the user what region they are interested in. and only provide information from that region. 8. When answering question, say what if the information is from what regiion. So, if a region is selected by user and specified in the question, then only answer based on that region and say so. Question: {{question}} """ general_user_template = "Question:```{question}```" messages_formatted = [ SystemMessagePromptTemplate.from_template(general_system_template), HumanMessagePromptTemplate.from_template(general_user_template) ] qa_prompt = ChatPromptTemplate.from_messages( messages_formatted) # print(qa_prompt) return qa_prompt # qa_prompt=get_prompt_with_vetted_info_from_specie_name("Papaipema nebris", "Researcher") # print("First prompt is intialized as: " , qa_prompt, "\n\n") memory = ConversationBufferMemory(memory_key="chat_history",output_key='answer', return_messages=True) # https://github.com/langchain-ai/langchain/issues/9394#issuecomment-1683538834 if model_name==4: llm_openai = ChatOpenAI(model_name="gpt-4o-2024-08-06" , temperature=0, max_tokens=max_tokens) # TODO: NEW MODEL VERSION AVAILABLE else: llm_openai = ChatOpenAI(model_name="gpt-3.5-turbo-0125" , temperature=0, max_tokens=max_tokens) specie_selector="Papaipema nebris" filter = { "$or": [ {"matched_specie_0": specie_selector}, {"matched_specie_1": specie_selector}, {"matched_specie_2": specie_selector}, ] } # retriever = vectordb.as_retriever(search_kwargs={'k':retriever_k_value, 'filter': filter}) # qa_chain = ConversationalRetrievalChain.from_llm( # llm_openai, retriever, memory=memory, verbose=False, return_source_documents=True,\ # combine_docs_chain_kwargs={'prompt': qa_prompt} # ) # def initialize_qa_chain(specie_selector, application_mode, model_name, region, database_persistent_directory=default_persist_directory): # Add helper function for India info (kept for potential future use, but removed from RAG prompt) def read_and_format_filtered_csv_better(dataframe_given, insect_specie): filtered_data = dataframe_given[dataframe_given['species'] == insect_specie] formatted_data = "" # Format the filtered data for index, row in filtered_data.iterrows(): row_data = [f"{col}: {row[col]}" for col in filtered_data.columns] formatted_row = "\n".join(row_data) formatted_data += f"{formatted_row}\n" return formatted_data # Get India info (potentially useful if not using RAG or for specific logic) india_info = read_and_format_filtered_csv_better(df_india, specie_selector) # db_region = get_db_region(region) # Map UI region to DB region - REMOVED if model_name=="GPT-4": chosen_llm=ChatOpenAI(model_name="gpt-4o-2024-08-06" , temperature=0, max_tokens=max_tokens) elif model_name=="GPT-3.5": chosen_llm=ChatOpenAI(model_name="gpt-3.5-turbo-0125" , temperature=0, max_tokens=max_tokens) elif model_name=="Llama-3 70B": chosen_llm = ChatOpenRouter(model_name="meta-llama/llama-3-70b-instruct", temperature=0,max_tokens=max_tokens ) elif model_name=="Llama-3 8B": chosen_llm = ChatOpenRouter(model_name="meta-llama/llama-3-8b-instruct", temperature=0, max_tokens=max_tokens) elif model_name=="Gemini-1.5 Pro": chosen_llm = ChatOpenRouter(model_name="google/gemini-pro-1.5", temperature=0, max_tokens=max_tokens) elif model_name=="Claude 3 Opus": chosen_llm = ChatAnthropic(model_name='claude-3-opus-20240229', temperature=0, max_tokens=max_tokens) elif model_name=="Claude 3.5 Sonnet": chosen_llm = ChatAnthropic(model_name='claude-3-5-sonnet-20240620', temperature=0, max_tokens=max_tokens) else: print("No appropriate llm was selected") exit() if application_mode == "Farmer": language_constraint = "The language should be customized for Farmers. The given question is likely to be asked by a farmer in the field and will help to make decisions which are immediate and practical." elif application_mode == "Researcher": language_constraint = "The language should be customized for a researcher. The given question is likely to be asked by a scientist and should be comprehensive, aimed at exploring new knowledge or refining existing methodologies." else: print("No valid mode provided. Exiting") exit() # RAG is always ON now memory = ConversationBufferMemory(memory_key="chat_history", output_key='answer', return_messages=True) # Construct the species filter part species_filter = { "$or": [ {"matched_specie_" + str(i): specie_selector} for i in range(11) # Generate dynamically up to 10 ] } embedding = OpenAIEmbeddings() vectordb = Chroma(persist_directory=database_persistent_directory, embedding_function=embedding) # --- Find all available regions for this species --- # availability_message = f"Checking region availability for {specie_selector}..." available_regions = set() try: # Query ChromaDB just for metadata based on species species_docs = vectordb.get(where=species_filter, include=['metadatas']) if species_docs and species_docs.get('metadatas'): for meta in species_docs['metadatas']: if 'region' in meta: available_regions.add(meta['region']) if available_regions: available_regions_list = sorted(list(available_regions)) availability_message = f"Information for **{specie_selector}** is available in region(s): **{', '.join(available_regions_list)}**." else: available_regions_list = [] availability_message = f"No regional information found for **{specie_selector}** in the database." except Exception as e: print(f"Error checking region availability: {e}") available_regions_list = [] availability_message = f"Could not determine region availability for {specie_selector}." # --- Prepare context sections by region --- # # Dictionary to hold context documents for each region # region_contexts = {} # Unused variable, removing # First check if selected region has information selected_region_has_info = region in available_regions # Create list of other available regions (excluding selected region) other_regions = [r for r in available_regions_list if r != region] # --- Create multi-region retrieval chain --- # class MultiRegionRetriever: def __init__(self, vectordb, species_filter, selected_region, other_regions, k=3): self.vectordb = vectordb self.species_filter = species_filter self.selected_region = selected_region self.other_regions = other_regions self.k = k def get_relevant_documents(self, query): all_docs = [] region_docs = {} # First get documents for selected region # Fix illogical condition: self.selected_region == self.selected_region is always True # Replace with a check if selected_region exists if self.selected_region: selected_filter = {"$and": [self.species_filter, {"region": self.selected_region}]} selected_retriever = self.vectordb.as_retriever(search_kwargs={'k': self.k, 'filter': selected_filter}) try: selected_docs = selected_retriever.get_relevant_documents(query) if selected_docs: all_docs.extend(selected_docs) region_docs[self.selected_region] = selected_docs except Exception as e: print(f"Error retrieving docs for selected region {self.selected_region}: {e}") # Then get documents for each other region for other_region in self.other_regions: if other_region != self.selected_region: # Skip if same as selected region other_filter = {"$and": [self.species_filter, {"region": other_region}]} other_retriever = self.vectordb.as_retriever(search_kwargs={'k': self.k, 'filter': other_filter}) try: other_docs = other_retriever.get_relevant_documents(query) if other_docs: all_docs.extend(other_docs) region_docs[other_region] = other_docs except Exception as e: print(f"Error retrieving docs for region {other_region}: {e}") # Store the region-specific documents for formatting in the prompt self.last_region_docs = region_docs return all_docs # Initialize the multi-region retriever multi_region_retriever = MultiRegionRetriever( vectordb=vectordb, species_filter=species_filter, selected_region=region, other_regions=available_regions_list, k=retriever_k_value ) # Custom prompt handler that formats context by region # Remove unused imports # from langchain.chains.combine_documents import create_stuff_documents_chain # from langchain.chains import create_retrieval_chain # Updated prompt template for multi-part response with region-specific contexts general_system_template = f""" You are an AI assistant specialized in providing information about agricultural pests ({specie_selector}). The user is primarily interested in the '{region}' region. The following context has been retrieved from a database organized by region: {{context}} Instructions: 1. Analyze the user's question in relation to {specie_selector}. 2. Structure your answer in the following multi-part format: **Part 1: Selected Region Information ({region})** If relevant information exists in the context for the selected region that answers the user's query: Based on your selected region ({region}), for {specie_selector}, [summary of information for selected region] [1]. If no relevant information exists for the selected region: "Based on the provided documents, there is no specific information for {specie_selector} in your selected region ({region}) regarding your question." **Part 2: Other Regions Information** (Only include if information from other regions is available AND relevant to the query) If you found relevant information from other regions that answers the user's query, include: Additionally, information was found for other regions: - In [Other Region Name]: [summary of information that directly answers the user's query] [next reference number]. - In [Another Region Name]: [summary of information that directly answers the user's query] [next reference number]. Only include regions where the information directly addresses the user's question. Use consecutive reference numbers starting from where Part 1 left off. If no other regions have relevant information, omit this part entirely. **Part 3: General Knowledge** (Only include if context information is insufficient or incomplete) If the available context does not fully address the query, add: Based on my general knowledge as {model_name}: [Your general knowledge insights that directly address the query] [next reference number]. If the context information is sufficient, omit this part entirely. 3. After providing all parts of your answer, include a References section ONLY for information you actually used: References: [1] Based on Expert Curated information about {specie_selector} in {region} [2] Based on Expert Curated information about {specie_selector} in [Other Region Name] [3] Based on Expert Curated information about {specie_selector} in [Another Region Name] [x] {model_name}'s inherent knowledge IMPORTANT: - Only include reference numbers that correspond to information you actually used in your answer. - Reference numbers should be sequential (1, 2, 3...) based on the order they appear in your answer. - If you don't use information from a particular region, don't include a reference for it. - If you don't use general knowledge, don't include a reference for it. - Every claim with a reference marker [x] must have a corresponding entry in the References section. 4. Apply this language constraint: {language_constraint} 5. Keep your summaries concise and directly related to the user's question. User Question about {specie_selector}: {{question}} """ class RegionFormattingLLMChain: def __init__(self, llm, prompt, retriever): self.llm = llm self.prompt = prompt self.retriever = retriever def __call__(self, inputs): # Get documents using the multi-region retriever docs = self.retriever.get_relevant_documents(inputs["question"]) # Get the region-specific document organization region_docs = getattr(self.retriever, "last_region_docs", {}) # Format context with clear region sections formatted_context = "" # First add context for selected region if available if region in region_docs: formatted_context += f"--- CONTEXT FROM SELECTED REGION: {region} ---\n" for i, doc in enumerate(region_docs[region]): formatted_context += f"Document {i+1} from {region}:\n{doc.page_content}\n\n" # Then add context for each other region for other_region in [r for r in region_docs.keys() if r != region]: formatted_context += f"--- CONTEXT FROM OTHER REGION: {other_region} ---\n" for i, doc in enumerate(region_docs[other_region]): formatted_context += f"Document {i+1} from {other_region}:\n{doc.page_content}\n\n" # Replace the context placeholder with our formatted context formatted_prompt = self.prompt.format( context=formatted_context, question=inputs["question"] ) # Call the LLM with our formatted prompt result = self.llm.invoke(formatted_prompt) # Return the result in the expected format return {"answer": result.content, "source_documents": docs} # Create the custom chain qa_chain = RegionFormattingLLMChain( llm=chosen_llm, prompt=general_system_template, retriever=multi_region_retriever ) return qa_chain, availability_message # result = qa_chain.invoke({"question": "where are stalk borer eggs laid?"}) # print("Got the first LLM task working: ", result) #Application Interface: with gr.Blocks(theme=gr.themes.Soft()) as demo: with gr.Row(): with gr.Column(scale=1): gr.Markdown( """ ![Logo](file/logo1.png) """ ) with gr.Column(scale=1): gr.Markdown( """ ![Logo](file/logo2.png) """ ) # Configure UI layout chatbot = gr.Chatbot(height=600, label="AgLLM") with gr.Row(): with gr.Column(scale=1): with gr.Row(): region_selector = gr.Dropdown( list(["United States", "India", "Africa"]), # Updated regions value="United States", # Updated default label="Region", info="Select the Region", interactive=True, scale=1, visible=True ) # Model selection specie_selector = gr.Dropdown( list(set(species_list)), value=species_list[0], label="Species", info="Select the Species", interactive=True, scale=1, visible=True ) with gr.Row(): model_name = gr.Dropdown( list(["GPT-4", "GPT-3.5", "Llama-3 70B", "Llama-3 8B", "Gemini-1.5 Pro", "Claude 3 Opus", "Claude 3.5 Sonnet"]), value="Llama-3 70B", label="LLM", info="Select the LLM", interactive=True, scale=1, visible=True ) application_mode = gr.Dropdown( list(["Farmer", "Researcher"]), value="Researcher", label="Mode", info="Select the Mode", interactive=True, scale=1, visible=True ) region_availability_display = gr.Markdown(value="Select species to see region availability.") # Added display area with gr.Column(scale=2): # User input prompt text field user_prompt_message = gr.Textbox(placeholder="Please add user prompt here", label="User prompt") with gr.Row(): # clear = gr.Button("Clear Conversation", scale=2) submitBtn = gr.Button("Submit", scale=8) state = gr.State([]) qa_chain_state = gr.State(value=None) # Handle user message def user(user_prompt_message, history): # print("HISTORY IS: ", history) # TODO: REMOVE IT LATER if user_prompt_message != "": return history + [[user_prompt_message, None]] else: return history + [["Invalid prompts - user prompt cannot be empty", None]] # Chatbot logic for configuration, sending the prompts, rendering the streamed back generations, etc. def bot(model_name, application_mode, user_prompt_message, history, messages_history, qa_chain, region): # Removed use_rag if qa_chain == None: # Initial QA chain setup if not already done (uses default species for the selected domain) initial_species = species_list[0] # Need to handle the tuple returned by init_qa_chain now # Use the currently selected region for initialization if qa_chain is None qa_chain, _ = init_qa_chain(initial_species, application_mode, model_name, region) # Pass region history[-1][1] = "" # Placeholder for the answer # RAG is always ON now result = qa_chain({"question": user_prompt_message, "chat_history": messages_history}) answer = result["answer"] # source_documents = result.get("source_documents", []) # Keep source_documents if needed for debugging or future refinement # formatted_response = format_response_with_source(answer, source_documents, domain_name, region) # REMOVED: Rely on LLM prompt now history[-1][1] = answer # Assign raw LLM answer directly return [history, messages_history] # Helper function to format the response with source information # def format_response_with_source(answer, source_documents, domain_name, region): # Pass region # FUNCTION NO LONGER USED # try: # answer_start = answer.find("Answer:") # source_start = answer.find("Source:") # ... (rest of the function commented out or removed) ... # except Exception as e: # print(f"Error parsing output or formatting source: {e}") # formatted_response = answer # Return raw answer on error # # return formatted_response # Initialize the chat history with default system message def init_history(messages_history): messages_history = [] messages_history += [system_message] return messages_history # Clean up the user input text field def input_cleanup(): return "" def init_qa_chain(specie_selector, application_mode, model_name, region): # Removed use_rag print(f"--- init_qa_chain wrapper called ---") # DIAGNOSTIC PRINT qa_chain_instance = None availability_msg = "Error initializing QA chain." try: qa_chain_instance, availability_msg = initialize_qa_chain(specie_selector, application_mode, model_name, region) # Removed use_rag except Exception as e: print(f"Error in init_qa_chain wrapper: {e}") availability_msg = f"Error initializing: {e}" return qa_chain_instance, availability_msg # Return both chain and message # Update QA chain AND availability message when relevant inputs change inputs_for_qa_chain = [specie_selector, application_mode, model_name, region_selector] # CORRECT ORDER outputs_for_qa_chain = [qa_chain_state, region_availability_display] # specie_selector.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) # model_name.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) # region_selector.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) # application_mode.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) # domain_name.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) specie_selector.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) model_name.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) region_selector.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) application_mode.change(init_qa_chain, inputs=inputs_for_qa_chain, outputs=outputs_for_qa_chain) ##### # When the user clicks Enter and the user message is submitted user_prompt_message.submit( user, [user_prompt_message, chatbot], [chatbot], queue=False ).then( bot, [model_name, application_mode, user_prompt_message, chatbot, state, qa_chain_state, region_selector], # Removed use_rag [chatbot, state] ).then(input_cleanup, [], [user_prompt_message], queue=False ) # When the user clicks the submit button submitBtn.click( user, [user_prompt_message, chatbot], [chatbot], queue=False ).then( bot, [model_name, application_mode, user_prompt_message, chatbot, state, qa_chain_state, region_selector], # Removed use_rag [chatbot, state] ).then( input_cleanup, [], [user_prompt_message], queue=False ) # When the user clicks the clear button # clear.click(lambda: None, None, chatbot, queue=False).success(init_history, [state], [state]) if __name__ == "__main__": # demo.launch() demo.queue().launch(allowed_paths=["/"], share=False, show_error=True)