Includes deal analysis

.env

@@ -1,2 +1,3 @@
 OPENAI_API_KEY="sk-FG-bvK9Xs1xfayztqm-POKfx4IlONcg488PnXTmCDvT3BlbkFJeVuGgSO0YQIQS7i5JrqfcZ0hrUyEylpaUQanJ0hawA"
-TAVILY_API_KEY="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"
+TAVILY_API_KEY="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"
+LANGCHAIN_API_KEY="lsck_01H3333333333333333333333333333333"

app.py

@@ -21,6 +21,7 @@ from utils_simulation import do_simulation
 dotenv.load_dotenv()
 openai_api_key = os.getenv("OPENAI_API_KEY")
 tavily_api_key = os.getenv("TAVILY_API_KEY")
+langchain_api_key = os.getenv("LANGCHAIN_API_KEY")
 
 llm_model = "gpt-4o-mini"
 set_llm_cache(InMemoryCache())

classes.py

@@ -1,7 +1,7 @@
 class SessionState:
     session_stage = ""
     do_evaluation = False
-    do_opportunity_analysis = False
+    do_opportunity_analysis = True
     do_customer_research = False
     do_objections = False
     add_objections_to_analysis = True   
@@ -33,10 +33,12 @@ class SessionState:
     command = ""
     scores = []
     llm_next_steps = ""
+    opportunity_review_results = None
+    opportunity_review_report = None
     def __init__(self):
         self.session_stage = "research"
         self.do_evaluation = False
-        self.do_opportunity_analysis = False
+        self.do_opportunity_analysis = True
         self.do_customer_research = True
         self.do_objections = False
         self.add_objections_to_analysis = False
@@ -72,6 +74,8 @@ class SessionState:
         self.customer = None
         self.opportunity = None
         self.scenario = None
+        self.opportunity_review_results = None
+        self.opportunity_review_report = None
     class Company:
         def __init__(self, name, description, product, product_summary, product_description):
             self.name = name

reports/HSBC Opportunity Review Report.md

@@ -0,0 +1,26 @@
+**Analysis Results**
+
+**Summary:** The opportunity with HSBC involves offering a new analytics engine for their loan origination system, which is currently slow and inflexible. The urgency for decision-making stems from their upcoming renewal with the existing vendor. Multiple meetings have taken place, including an initial discovery call, a technical deep dive, and a proposal review, with HSBC expressing interest in moving forward. The next step involves further discussions with John Smith, the VP of Information Technology, to potentially proceed to a pilot program or final negotiations.
+
+**Score:** 75
+
+**MEDDIC Evaluation:**
+
+**Metrics:** 80
+**Evaluation:** John Smith appears to be a potential champion, given his active involvement. However, it is uncertain how strongly he advocates for the solution internally or if there are other champions within HSBC. Further development of internal champions may be needed.
+**Economic Buyer:** 70
+**Decision Criteria:** 75
+**Decision Process:** 70
+**Identify Pain:** 85
+**Champion:** 65
+
+
+**Next Steps**
+
+Schedule a meeting with John Smith to deepen the understanding of HSBC's decision-making process and to identify additional internal champions. Aim to set the groundwork for a pilot program or final negotiations.
+
+**Talking Points:**
+
+  1. **Reinforce the Value Proposition**: Highlight how the new analytics engine will enhance HSBC's loan origination system by improving speed and flexibility, directly addressing the current pain points
+  2. **Discuss the Timeline and Urgency**: Emphasize the importance of aligning with HSBC's renewal timeline to ensure a smooth transition from their existing vendor, and address any potential roadblocks in the decision-making process
+  3. **Identify and Develop Additional Champions**: Explore who else within HSBC might benefit from or support the new solution, and strategize on how to engage these stakeholders to strengthen internal advocacy

requirements.txt

@@ -52,4 +52,5 @@ openai-whisper==20240930
 # Nitins dependencies
 fpdf==1.7.2
 tavily-python==0.5.0
-langgraph==0.2.34
+langgraph==0.2.34
+docx2txt==0.8

utils_callbacks.py

@@ -65,8 +65,6 @@ async def callback_run_scenario(action):
     ]
     await cl.Message(content="Click to start simulation", actions=start_actions).send()
 
-
-
 async def callback_start_scenario():
     print("callback_start_scenario()")
     session_state = cl.user_session.get("session_state", None)

utils_customer_research.py

@@ -334,4 +334,5 @@ async def generete_pdf(state: ResearchState):
 
     msg = generate_pdf_from_md(state['report'], filename=pdf_file_path)
 
-    return {"messages": [AIMessage(content=msg)]}
+    return {"messages": [AIMessage(content=msg)]}
+

utils_opportunity_review.py

@@ -0,0 +1,355 @@
+import json
+import os
+from langchain.document_loaders import CSVLoader, PyPDFLoader, Docx2txtLoader
+from langgraph.graph import StateGraph, END
+from langchain.prompts import PromptTemplate
+from langchain.schema import Document, AIMessage
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from pathlib import Path
+from pydantic import BaseModel, Field
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+from typing import List, Dict, Any
+
+from pydantic import BaseModel, Field
+from typing import Dict, Any
+
+
+llm = ChatOpenAI(model_name="gpt-4o")
+embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+qdrant = QdrantClient(":memory:")  # In-memory Qdrant instance
+
+# Create collection
+qdrant.create_collection(
+    collection_name="opportunities",
+    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
+)
+
+class State(BaseModel):
+    file_path: str
+    document_processed: str = ""
+    opportunity_evaluation: Dict[str, Any] = Field(default_factory=dict)
+    next_action: Dict[str, Any] = Field(default_factory=dict)
+
+    def dict_representation(self) -> Dict[str, Any]:
+        return {
+            "file_path": self.file_path,
+            "document_processed": self.document_processed,
+            "opportunity_evaluation": self.opportunity_evaluation,
+            "next_action": self.next_action
+        }
+
+async def prep_opportunity_review(session_state):
+    file_path = prep_document()            
+    structured_results = run_analysis(file_path)
+    opportunity_review_report = create_opportunity_review_report(structured_results)
+    session_state.opportunity_review_results = structured_results
+    session_state.opportunity_review_report = opportunity_review_report
+    
+
+def prep_document():
+    file_path = "data/HSBC Opportunity Information.docx"
+    path = Path(file_path)
+
+    if path.exists():
+        if path.is_file():
+            print(f"File found: {path}")
+            print(f"File size: {path.stat().st_size / 1024:.2f} KB")
+            print(f"Last modified: {path.stat().st_mtime}")
+            print("File is ready for processing.")
+            if os.access(path, os.R_OK):
+                print("File is readable.")
+            else:
+                print("Warning: File exists but may not be readable. Check permissions.")
+        else:
+            print(f"Error: {path} exists but is not a file. It might be a directory.")
+    else:
+        print(f"Error: File not found at {path}")
+        print("Please check the following:")
+        print("1. Ensure the file path is correct.")
+        print("2. Verify that the file exists in the specified location.")
+        print("3. Check if you have the necessary permissions to access the file.")
+
+        parent = path.parent
+        if not parent.exists():
+            print(f"Note: The directory {parent} does not exist.")
+        elif not parent.is_dir():
+            print(f"Note: {parent} exists but is not a directory.")
+
+    file_path_for_processing = str(path)
+    return file_path_for_processing
+
+def load_and_chunk_document(file_path: str) -> List[Document]:
+    """Load and chunk the document based on file type."""
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+    
+    _, file_extension = os.path.splitext(file_path.lower())
+    
+    if file_extension == '.csv':
+        loader = CSVLoader(file_path)
+    elif file_extension == '.pdf':
+        loader = PyPDFLoader(file_path)
+    elif file_extension == '.docx':
+        loader = Docx2txtLoader(file_path)
+    else:
+        raise ValueError(f"Unsupported file type: {file_extension}")
+    
+    documents = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    return text_splitter.split_documents(documents)
+
+def agent_1(file_path: str) -> str:
+    """Agent 1: Load, chunk, embed, and store document in Qdrant."""
+    try:
+        chunks = load_and_chunk_document(file_path)
+        points = []
+        for i, chunk in enumerate(chunks):
+            vector = embeddings.embed_query(chunk.page_content)
+            points.append(PointStruct(id=i, vector=vector, payload={"text": chunk.page_content}))
+        
+        qdrant.upsert(
+            collection_name="opportunities",
+            points=points
+        )
+        return f"Document processed and stored in Qdrant. {len(chunks)} chunks created."
+    except Exception as e:
+        print(f"Error in agent_1: {str(e)}")
+        return f"Error processing document: {str(e)}"
+    
+def agent_2() -> Dict[str, Any]:
+    """Agent 2: Evaluate opportunity based on MEDDIC criteria."""
+    try:
+        results = qdrant.scroll(collection_name="opportunities", limit=100)
+        if not results or len(results[0]) == 0:
+            raise ValueError("No documents found in Qdrant")
+
+        full_text = " ".join([point.payload.get("text", "") for point in results[0]])
+        
+        meddic_template = """
+        Analyze the following opportunity information using the MEDDIC sales methodology:
+
+        {opportunity_info}
+
+        Assign an overall opportunity score (1-100) with 100 means that the opportunity is a sure win.
+
+        Provide a Summary of the opportunity.
+
+        Evaluate the opportunity based on each MEDDIC criterion and assign a score for each criterion:
+        1. Metrics
+        2. Economic Buyer
+        3. Decision Criteria
+        4. Decision Process
+        5. Identify Pain
+        6. Champion
+
+        Format your response as follows:
+        Summary: [Opportunity Summary]
+        Score: [Overall Opportunity Score between 1 to 100 based on MEDDIC criteria]
+        MEDDIC Evaluation:
+        - Metrics: [Score on Metrics, Evaluation on Metrics criterion]
+        - Economic Buyer: [Score on Economic Buyer, Evaluation on Economic Buyer criterion]
+        - Decision Criteria: [Score on Decision Criteria, Evaluation on Decision Criteria criterion]
+        - Decision Process: [Score on Decision Process, Evaluation on Decision Process criterion]
+        - Identify Pain: [Score on Identify Pain, Evaluation on Identify Pain criterion]
+        - Champion: [Score on Champion, Evaluation on Champion criterion]
+        """
+
+        meddic_prompt = PromptTemplate(template=meddic_template, input_variables=["opportunity_info"])
+        meddic_chain = meddic_prompt | llm
+        
+        response = meddic_chain.invoke({"opportunity_info": full_text})
+        
+        if isinstance(response, AIMessage):
+            response_content = response.content
+        elif isinstance(response, str):
+            response_content = response
+        else:
+            raise ValueError(f"Unexpected response type: {type(response)}")
+        
+        # Parse the response content
+        lines = response_content.split('\n')
+        summary = next((line.split('Summary:')[1].strip() for line in lines if line.startswith('Summary:')), 'N/A')
+        score = next((int(line.split('Score:')[1].strip()) for line in lines if line.startswith('Score:')), 0)
+        meddic_eval = {}
+        current_criterion = None
+        for line in lines:
+            if line.strip().startswith('-'):
+                parts = line.split(':', 1)
+                if len(parts) == 2:
+                    current_criterion = parts[0].strip('- ')
+                    meddic_eval[current_criterion] = parts[1].strip()
+            elif current_criterion and line.strip():
+                meddic_eval[current_criterion] += ' ' + line.strip()
+
+        return {
+            'summary': summary,
+            'score': score,
+            'meddic_evaluation': meddic_eval
+        }
+
+    except Exception as e:
+        print(f"Error in agent_2: {str(e)}")
+        return {
+            'summary': "Error occurred during evaluation",
+            'score': 0,
+            'meddic_evaluation': str(e)
+        }
+    
+def agent_3(meddic_evaluation: Dict[str, Any]) -> Dict[str, Any]:
+    """Agent 3: Suggest next best action and talking points."""
+    try:
+        next_action_template = """
+        Based on the following MEDDIC evaluation of an opportunity:
+
+        {meddic_evaluation}
+
+        Suggest the next best action for the upcoming customer meeting and provide the top 3 talking points.
+        Format your response as follows:
+        Next Action: [Your suggested action]
+        Talking Points:
+        1. [First talking point]
+        2. [Second talking point]
+        3. [Third talking point]
+        """
+
+        next_action_prompt = PromptTemplate(template=next_action_template, input_variables=["meddic_evaluation"])
+        next_action_chain = next_action_prompt | llm
+        
+        response = next_action_chain.invoke({"meddic_evaluation": json.dumps(meddic_evaluation)})
+        
+        if isinstance(response, AIMessage):
+            response_content = response.content
+        elif isinstance(response, str):
+            response_content = response
+        else:
+            raise ValueError(f"Unexpected response type: {type(response)}")
+        
+        # Parse the response content
+        lines = response_content.split('\n')
+        next_action = next((line.split('Next Action:')[1].strip() for line in lines if line.startswith('Next Action:')), 'N/A')
+        talking_points = [line.split('.')[1].strip() for line in lines if line.strip().startswith(('1.', '2.', '3.'))]
+
+        return {
+            'next_action': next_action,
+            'talking_points': talking_points
+        }
+    except Exception as e:
+        print(f"Error in agent_3: {str(e)}")
+        return {
+            'next_action': "Error occurred while suggesting next action",
+            'talking_points': [str(e)]
+        }
+    
+def process_document(state: State) -> State:
+    print("Agent 1: Processing document...")
+    file_path = state.file_path
+    result = agent_1(file_path)
+    return State(file_path=state.file_path, document_processed=result)
+
+def evaluate_opportunity(state: State) -> State:
+    print("Agent 2: Evaluating opportunity...")
+    result = agent_2()
+    return State(file_path=state.file_path, document_processed=state.document_processed, opportunity_evaluation=result)
+
+def suggest_next_action(state: State) -> State:
+    print("Agent 3: Suggesting next actions...")
+    result = agent_3(state.opportunity_evaluation)
+    return State(file_path=state.file_path, document_processed=state.document_processed, opportunity_evaluation=state.opportunity_evaluation, next_action=result)
+
+def define_graph() -> StateGraph:
+    workflow = StateGraph(State)
+    
+    workflow.add_node("process_document", process_document)
+    workflow.add_node("evaluate_opportunity", evaluate_opportunity)
+    workflow.add_node("suggest_next_action", suggest_next_action)
+    
+    workflow.set_entry_point("process_document")
+    workflow.add_edge("process_document", "evaluate_opportunity")
+    workflow.add_edge("evaluate_opportunity", "suggest_next_action")
+    
+    return workflow
+
+
+def run_analysis(file_path: str) -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {"error": f"File not found: {file_path}"}
+    
+    graph = define_graph()
+    initial_state = State(file_path=file_path)
+    
+    try:
+        app = graph.compile()
+        final_state = app.invoke(initial_state)
+        
+        # Convert the final state to a dictionary manually
+        structured_results = {
+            "file_path": final_state["file_path"],
+            "document_processed": final_state["document_processed"],
+            "opportunity_evaluation": final_state["opportunity_evaluation"],
+            "next_action": final_state["next_action"]
+        }
+        
+        # Print a summary of the results
+        print("\n--- Analysis Results ---")
+        print(f"Document Processing: {'Successful' if 'Error' not in structured_results['document_processed'] else 'Failed'}")
+        print(f"Details: {structured_results['document_processed']}")
+        
+        if isinstance(structured_results['opportunity_evaluation'], dict):
+            print("\nOpportunity Evaluation:")
+            print(f"Summary: {structured_results['opportunity_evaluation'].get('summary', 'N/A')}")
+            print(f"Score: {structured_results['opportunity_evaluation'].get('score', 'N/A')}")
+            print("MEDDIC Evaluation:")
+            for criterion, evaluation in structured_results['opportunity_evaluation'].get('meddic_evaluation', {}).items():
+                print(f"{criterion}: {evaluation}")
+        else:
+            print("\nOpportunity Evaluation:")
+            print(f"Error: {structured_results['opportunity_evaluation']}")
+        
+        if isinstance(structured_results['next_action'], dict):
+            print("\nNext Action:")
+            print(f"Action: {structured_results['next_action'].get('next_action', 'N/A')}")
+            print("Talking Points:")
+            for i, point in enumerate(structured_results['next_action'].get('talking_points', []), 1):
+                print(f"  {i}. {point}")
+        else:
+            print("\nNext Action:")
+            print(f"Error: {structured_results['next_action']}")
+        
+        return structured_results
+    
+    except Exception as e:
+        print(f"An error occurred during analysis: {str(e)}")
+        return {"error": str(e)}
+
+def create_opportunity_review_report(structured_results):
+    opportunity_review_report = ""
+    opportunity_review_report += "**Analysis Results**\n\n"
+    if 'Error' in structured_results['document_processed']:
+        opportunity_review_report += f"Opportunity Analysis Failed\n"
+
+    else:
+        if isinstance(structured_results['opportunity_evaluation'], dict):
+            opportunity_review_report += f"**Summary:** {structured_results['opportunity_evaluation'].get('summary', 'N/A')}\n\n"
+            opportunity_review_report += f"**Score:** {structured_results['opportunity_evaluation'].get('score', 'N/A')}\n\n"
+            opportunity_review_report += "**MEDDIC Evaluation:**\n\n"
+            for criterion, evaluation in structured_results['opportunity_evaluation'].get('meddic_evaluation', {}).items():
+                opportunity_review_report += f"**{criterion}:** {evaluation}\n"
+        
+        if isinstance(structured_results['next_action'], dict):
+            opportunity_review_report += "\n\n**Next Steps**\n\n"
+            opportunity_review_report += f"{structured_results['next_action'].get('next_action', 'N/A')}\n\n"
+            opportunity_review_report += "**Talking Points:**\n\n"
+            for i, point in enumerate(structured_results['next_action'].get('talking_points', []), 1):
+                opportunity_review_report += f"  {i}. {point}\n"
+    file_path = "reports/HSBC Opportunity Review Report.md"
+    save_md_file(file_path, opportunity_review_report)
+    return opportunity_review_report
+
+def save_md_file(file_path, file_content):
+    if os.path.exists(file_path):
+        os.remove(file_path)
+        print(f"Existing file deleted: {file_path}")
+    with open(file_path, 'w', encoding='utf-8') as md_file:
+        md_file.write(file_content)

utils_prep.py

@@ -1,12 +1,14 @@
 import asyncio
 import chainlit as cl
+import os
 from langchain_openai import ChatOpenAI
 
 from utils_actions import offer_actions,offer_initial_actions
+from utils_customer_research import read_markdown_file
 from utils_data import get_company_data, get_opportunities
-from utils_prompt import get_chat_prompt
 from utils_objections import create_objections
-
+from utils_opportunity_review import prep_opportunity_review
+from utils_prompt import get_chat_prompt
 
 async def prep_start(session_state):
 
@@ -64,7 +66,11 @@ async def prep_opportunity_analysis():
     await cl.Message(content=opportunity_analysis_message).send()
     
     if session_state.do_opportunity_analysis:
-        pass
+        agent_1_message = "*Retrieving and reviewing opportunity data from SalesForce CRM ...*"
+        await cl.Message(content=agent_1_message).send()
+        await prep_opportunity_review(session_state)
+        report = session_state.opportunity_review_report
+        await cl.Message(content=report).send()
     else:
 
         agent_1_message = "*Retrieving data from SalesForce CRM ...*"
@@ -85,24 +91,29 @@ async def prep_opportunity_analysis():
         await asyncio.sleep(1)
         output_message = "**Analysis Results**"
         await cl.Message(content=output_message).send()
-        output_messages = get_opportunity_analysis()
-        for output_message in output_messages:  
-            await cl.Message(content=output_message).send()
-            await cl.Message(content="").send() 
 
-        if session_state.add_objections_to_analysis:
-            output_message = "**Risks**"
-            await cl.Message(content=output_message).send()
-            for obj in session_state.objections:
-                await cl.Message(content=obj).send()
-
-        output_message = "**Next Steps**"
-        await cl.Message(content=output_message).send()
-        output_messages = get_next_steps()
-        for output_message in output_messages:  
+        markdown_file_path = "reports/HSBC Opportunity Review Report.md"
+        if os.path.exists(markdown_file_path):
+            await cl.Message(content=read_markdown_file(markdown_file_path)).send() 
+        else:
+            output_messages = get_opportunity_analysis()
+            for output_message in output_messages:  
+                await cl.Message(content=output_message).send()
+                await cl.Message(content="").send() 
+
+            if session_state.add_objections_to_analysis:
+                output_message = "**Risks**"
+                await cl.Message(content=output_message).send()
+                for obj in session_state.objections:
+                    await cl.Message(content=obj).send()
+
+            output_message = "**Next Steps**"
             await cl.Message(content=output_message).send()
-            await cl.Message(content="").send() 
-        await cl.Message(content="\n\n").send()
+            output_messages = get_next_steps()
+            for output_message in output_messages:  
+                await cl.Message(content=output_message).send()
+                await cl.Message(content="").send() 
+            await cl.Message(content="\n\n").send()
 
     await offer_actions()