Upload 3 files

main1.py

@@ -0,0 +1,134 @@
+import gradio as gr
+from setup import *
+import pandas as pd
+from openpyxl import Workbook
+from openpyxl.utils.dataframe import dataframe_to_rows
+from openpyxl.styles import Font
+from feasibility_agent import feasibility_agent_func
+from short import graph
+
+
+# # Function to create Excel file
+# def create_excel(df):
+#     # Create a new Excel workbook and select the active sheet
+#     wb = Workbook()
+#     ws = wb.active
+#     ws.title = "Use Cases"
+
+#     # Define and write headers to the Excel sheet
+#     headers = ['Use Case', 'Description', 'URLs']
+#     ws.append(headers)
+
+#     # Write data rows
+#     for _, row in df.iterrows():
+#         try:
+#             use_case = row['use_case']
+#             description = row['description']
+#             urls = row['urls_list']
+
+#             ws.append([use_case, description, None])  # Add use case and description
+#             if urls:
+#                 for url_index, url in enumerate(urls):
+#                     cell = ws.cell(row=ws.max_row, column=3)  # URLs go into the third column
+#                     cell.value = url
+#                     cell.hyperlink = url
+#                     cell.font = Font(color="0000FF", underline="single")
+                    
+#                     # Add a new row for additional URLs
+#                     if url_index < len(urls) - 1:
+#                         ws.append([None, None, None])
+#         except KeyError as e:
+#             print(f"Missing key in DataFrame row: {e}")
+#         except Exception as e:
+#             print(f"Unexpected error while processing row: {e}")
+
+#     excel_file_path = "GenAI_use_cases_feasibility.xlsx"
+#     wb.save(excel_file_path)
+#     return excel_file_path
+
+
+# # Function to handle the report and create the DataFrame
+# def pd_creation(report):
+#     # Assuming feasibility_agent_func returns a dictionary
+#     pd_dict = feasibility_agent_func(report)
+    
+#     # Check for expected keys in pd_dict before proceeding
+#     required_columns = ['use_case', 'description', 'urls_list']
+#     print("-----Dict------->", pd_dict)
+#     # if not all(col in pd_dict for col in required_columns):
+#     #     raise ValueError(f"Missing one or more expected columns: {required_columns}")
+
+#     # Create the DataFrame from the dictionary
+#     df = pd.DataFrame(pd_dict)
+    
+#     # Convert the dataframe to the format expected by Gradio (list of lists)
+#     data = df.values.tolist()  # This creates a list of lists from the dataframe
+    
+#     # Create the Excel file and return its path
+#     excel_file_path = create_excel(df)  # Create the Excel file and get its path
+    
+#     return data, excel_file_path  # Return the formatted data and the Excel file path
+
+# Main function that handles the user query and generates the report
+def main(user_input):
+    topic = user_input
+    report = graph(topic=topic, max_analysts=5)
+    print(report)
+    # pd_dict, excel_file_path = pd_creation(report)
+    
+    # Save the report as a markdown file
+    report_file_path = "generated_report.md"
+    with open(report_file_path, "w") as f:
+        f.write(report)
+
+    return report, report_file_path
+
+# Example queries
+examples = [
+    "How is the retail industry leveraging AI and ML?",
+    "AI applications in automotive manufacturing"
+]
+
+# Creating the Gradio interface
+with gr.Blocks(theme=gr.themes.Soft(font=gr.themes.GoogleFont('Open Sans'))) as demo:
+    # Header section
+    gr.HTML("<center><h1>UseCaseGenie - Discover GenAI Use cases for your company and Industry! 🤖🧑‍🍳.</h1><center>") 
+    gr.Markdown("""#### This GenAI Assistant 🤖 helps you discover and explore Generative AI use cases for your company and industry. 
+    You can download the generated use case report as a <b>Markdown file</b> to gain insights and explore relevant GenAI applications.
+    ### <b>Steps:</b>
+    1. <b>Enter your query</b> regarding any company or industry.  
+    2. <b>Click on the 'Submit' button</b> and wait for the GenAI assistant to generate the report.  
+    3. <b>Download the generated report<b> 
+    4. Explore the GenAI use cases""")
+    gr.Markdown("**Note:** The app demo may occasionally show errors due to rate limits of the underlying language model (LLM). If you encounter an error, please try again later. If the problem persists please raise issue. Thank you for your understanding!")
+
+    # Input for the user query
+    with gr.Row():
+      user_input = gr.Textbox(label="Enter your Query", placeholder='Type_here...')
+
+    # Examples to help users with inputs
+    with gr.Row():  
+      gr.Examples(examples=examples, inputs=user_input)
+
+    # Buttons for submitting and downloading
+    with gr.Row():
+      submit_button = gr.Button("Submit")
+      clear_btn = gr.ClearButton([user_input], value='Clear')
+
+    # File download buttons
+    with gr.Row():
+      # Create a downloadable markdown file
+      download_report_button = gr.File(label="Usecases Report")    
+
+      # # Create a downloadable Excel file
+      # download_excel_button = gr.File(label="Feasibility Excel File")   
+
+    # Display report in Markdown format
+    with gr.Row():
+      report_output = gr.Markdown()
+
+    submit_button.click(main, inputs=[user_input], outputs=[report_output, download_report_button])
+
+# Run the interface
+demo.launch()
+

setup.py

@@ -0,0 +1,33 @@
+import os
+import getpass
+from dotenv import load_dotenv
+from langchain_groq import ChatGroq
+from langchain_cohere import ChatCohere
+from langchain_community.tools import TavilySearchResults
+
+load_dotenv()
+
+def _set_env(var: str):
+  if not os.environ.get(var):
+    os.environ[var] = getpass.getpass(f"Enter {var}: ")
+
+
+# Setting up environmentl_variables
+# _set_env("GROQ_API_KEY")
+_set_env("TAVILY_API_KEY")
+
+
+
+# llm defined
+llm1 = ChatGroq(temperature=0.5, model_name="llama-3.1-8b-instant", api_key='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')
+llm2 = ChatGroq(temperature=0.7, model_name="qwen-qwq-32b", api_key='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')
+# llm3 = ChatCohere(model='command-a-03-2025', cohere_api_key='AjWeplJ8UcvyKktAT5lSVbSnTGxZu0l2scBExWVN')
+
+# search tool
+tavily_search = TavilySearchResults(
+    max_results=2,
+    search_depth="advanced",
+    include_answer=True,
+    include_raw_content=True,
+    include_images=True,
+)

short.py

@@ -0,0 +1,144 @@
+from pydantic import BaseModel,Field
+from typing import TypedDict, Annotated
+from langgraph.graph import MessagesState,StateGraph, START, END
+from langchain_community.tools import TavilySearchResults
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_community.document_loaders import WebBaseLoader
+from langgraph.checkpoint.memory import MemorySaver
+
+
+import operator
+from setup import *
+
+class GeneratorState(MessagesState):
+  context : Annotated[list, operator.add] # retrived docs
+  max_usecase : int # no of usecase to generate
+  topic : str # input query
+
+
+class SearchQuery(BaseModel):
+  search_query : str = Field(description = 'Search query for web-search')
+
+
+keyword_search = TavilySearchResults(
+  max_results=1,
+  search_depth="advanced",
+  include_answer=True,
+  include_raw_content=True,
+  include_images=True)
+
+
+
+def search_web(state: GeneratorState):
+  
+  topic = state['topic']
+  structured_llm = llm2.with_structured_output(SearchQuery)
+  
+  search_instructions = """You are an AI assistant specialized in generating effective internet search queries. Your goal is to create **precise, keyword-rich search queries** that retrieve the best results for **AI use cases in specific industries** using Tavily Search.  
+
+    ## **Instructions:**
+    - Extract the **industry name** from the user’s query.
+    - Generate a **focused search query** that retrieves **practical AI use cases** in that industry.
+    - Include keywords like **"applications," "use cases," "impact," or "case studies"** to refine the search.
+    - Prioritize sources like **research papers, industry reports, and authoritative tech sites**.
+    - Use **Google-style operators (e.g., `site:`) to focus on trusted sources** if applicable.
+
+    ---
+    ## **Example:**
+    User Input: `"GenAI in healthcare"`  
+    Generated Query:  
+    "Generative AI use cases in healthcare applications and impact"
+
+    Generate search query for the below:
+    {topic}
+    """
+
+  search_prompt = search_instructions.format(topic=topic)
+  search_query = structured_llm.invoke(search_prompt)
+  exclude_domains = ["vktr.com"]
+  search_docs = tavily_search.invoke(search_query.search_query, exclude_domains=exclude_domains)
+  page_url = [doc['url'] for doc in search_docs]
+  loader = WebBaseLoader(
+    web_paths= page_url,
+    bs_get_text_kwargs={"separator": "|", "strip": True},
+    raise_for_status=True,
+  )
+  docs = loader.load()
+  formatted_search_docs = "\n\n---\n\n".join(
+    [
+      f'<Document href="{doc.metadata['source']}"/>\n{doc.page_content}\n</Document>'
+      for doc in docs
+    ])
+  
+  summarization_prompt = '''You are an advanced summarization assistant. Your task is to generate a 500-word summary based on the provided context. 
+    Maintain key information while removing redundancy, preserving critical details, and ensuring readability. Follow these guidelines:
+    Focus on Key Points: Extract essential facts, insights, and takeaways.
+    Maintain Clarity & Coherence: Ensure logical flow and readability.
+    Preserve Critical Data: Retain names, dates, figures, and important references.
+    Adjust Length as Needed: Summarize concisely while covering all vital aspects.
+    Format the summary professionally, adapting tone and detail to match the context.
+    context : {formatted_search_docs}
+  '''
+  summarized_docs = llm2.invoke([SystemMessage(content=summarization_prompt)])
+
+  return {'context': [summarized_docs]}
+
+
+
+def generate_usecases(state: GeneratorState):
+  topic = state['topic']
+  context = state['context']
+  generation_prompt = '''
+    You are a highly skilled technical writer. Your task is to consolidate insights from analyst memos into a structured report based on the given context and topic. Ensure the report includes a **brief introduction**, at least five AI use cases, and a **short conclusion**. Follow this format:  
+    topic : {topic}
+    context:
+    {context}
+
+    # Focus Title: [Provided Title]  
+
+    ## Introduction:
+      Provide a concise overview of the report's purpose and relevance.  
+
+    ## Use Case 1: [Descriptive Title]  
+    **Objective/Use Case:** Summarize the goal in one or two sentences.  
+    **AI Application:** Describe the AI technologies used.  
+    **Cross-Functional Benefit:**  
+    - **[Department]:** [Benefit]  
+    - **[Department]:** [Benefit]  
+
+    ## Use Case 2: [Descriptive Title]  
+    (Repeat format)  
+
+    ## Conclusion:
+      Summarize key takeaways and potential future implications.  
+
+    Ensure clarity, relevance, and no duplicate citations in the **Sources** section. Extract insights accurately from the **context** provided.'''
+
+  system_message = generation_prompt.format(topic=topic, context=context)
+  answer = llm1.invoke([SystemMessage(content=system_message)])
+
+  return {'messages': answer}
+
+
+
+def graph(topic,max_analysts):
+  graph_builder = StateGraph(GeneratorState)
+
+  graph_builder.add_node('search_web', search_web)
+  graph_builder.add_node('usecase_generation', generate_usecases)
+
+  graph_builder.add_edge(START, 'search_web')
+  graph_builder.add_edge('search_web', 'usecase_generation')
+  graph_builder.add_edge('usecase_generation', END)
+
+  memory = MemorySaver()
+  graph = graph_builder.compile(checkpointer=memory)
+  config = {"configurable": {"thread_id": "1"}}
+  graph.invoke({"topic":topic,
+                "max_analysts":max_analysts}, 
+                config)
+  
+  final_state = graph.get_state(config)
+  report = final_state.values['messages'][0].content
+  
+  return report