Upload 47 files

readme.md

@@ -0,0 +1,15 @@
+# Company Researcher Tool
+
+## Overview
+This project provides an AI-powered tool to analyze and generate comprehensive reports on a company. It includes industry research, competitor analysis, market trends, financial data, and SWOT analysis.
+
+## Project Structure
+- `src/`: Source code for agents, tasks, tools, and utilities.
+- `tests/`: Unit tests for the project.
+- `requirements.txt`: Python dependencies.
+
+## Installation
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/your-repo/company-researcher-tool.git
+   cd company-researcher-tool

requirements.txt

@@ -0,0 +1,12 @@
+crewai
+crewai_tools
+langchain_community
+langchain-together
+langchain-google-genai
+streamlit
+pandas
+yfinance
+yahooquery
+tensorflow_hub
+scikit-learn
+reportlab

src/agents/competitor_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import pdf_tool,scrape_tool,search_tool,comp_tool
+
+competitor_analyst_agent = Agent(
+    role="Competitor Researcher",
+    goal="Uncover and analyze key competitors for {company}.",
+    backstory="You are a seasoned researcher with an extraordinary ability to uncover the latest developments and emerging competitors for any company, especially when it comes to {company}. Your expertise lies in sifting through information, identifying key trends, and pinpointing companies that are poised to disrupt the market. Whether it's analyzing business models or tracking industry movements, you are known for your strategic approach to competitor analysis.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool, comp_tool, pdf_tool]
+)

src/agents/financial_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import scrape_tool,search_tool,pdf_tool
+
+financial_analyst_agent = Agent(
+    role="Financial Analyst",
+    goal="Perform a detailed financial analysis of the company {company}.",
+    backstory="You are a seasoned financial analyst with a deep understanding of financial statements, ratios, and market benchmarks. Your ability to analyze financial data and provide insights into a company's financial health and performance is crucial for strategic decision-making. You should avoid the PDF tool for this analysis.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool,pdf_tool]
+)

src/agents/industry_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import pdf_tool,scrape_tool,search_tool
+
+industry_analyst_agent = Agent(
+    role="Industry Research Specialist",
+    goal="Conduct thorough research on this company/industry {company} to understand their key offerings and strategic focus areas.",
+    backstory="You are an expert in industry analysis with years of experience in market research. Your ability to quickly grasp the nuances of various industries and identify key players and trends is unparalleled. You use your skills to provide comprehensive insights that form the foundation for strategic decision-making.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool, pdf_tool]
+)

src/agents/market_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import pdf_tool,scrape_tool,search_tool
+
+market_analyst_agent = Agent(
+    role="Market Analyst",
+    goal="Conduct a thorough market analysis for the company/industry {company}.",
+    backstory="You are an expert in market analysis with a keen eye for identifying key market trends, drivers, and challenges. Your ability to synthesize data from various sources and provide actionable insights is highly valued. You help companies understand their market position and the factors influencing their growth and success.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool, pdf_tool]
+)

src/agents/reporting_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import pdf_tool,scrape_tool,search_tool
+
+reporting_analyst_agent = Agent(
+    role="Reporting Analyst",
+    goal="Create sophisticated reports based on findings from industry, competitor, market, financial, and SWOT analysts about {company}.",
+    backstory="You are a reporting analyst responsible for compiling and synthesizing data from various analysts into comprehensive reports. Your reports aid strategic decision-making by providing a holistic view of {company}'s current standing and future prospects.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool, pdf_tool]
+)

src/agents/swot_analyst_agent.py

@@ -0,0 +1,11 @@
+from crewai import Agent
+from src.tools.tools import pdf_tool,scrape_tool,search_tool
+
+swot_analyst_agent = Agent(
+    role="SWOT Analyst",
+    goal="Conduct a comprehensive SWOT analysis for the company {company}.",
+    backstory="You are an expert in SWOT analysis, skilled at identifying a company's strengths, weaknesses, opportunities, and threats. Your ability to provide a balanced and insightful analysis is essential for strategic planning and risk management.",
+    verbose=True,
+    allow_delegation=True,
+    tools=[scrape_tool, search_tool, pdf_tool]
+)

src/app.py

@@ -0,0 +1,54 @@
+import streamlit as st
+from crew_initializer import initialize_crew
+from utils.pdf_generator import generate_pdf
+import json
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Custom JSON Encoder
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        try:
+            # Convert objects with __dict__ attributes to dictionaries
+            if hasattr(obj, "__dict__"):
+                return obj.__dict__
+            return super().default(obj)
+        except TypeError:
+            return str(obj)  # Fallback for unsupported types
+
+def main():
+    """
+    Main entry point for the Streamlit application.
+    Handles user input, executes tasks, and displays results.
+    """
+    st.title("Company Researcher Tool")
+
+    st.sidebar.header("Provide Company Details")
+    company_name = st.sidebar.text_input("Enter the Company Name:", "")
+
+    if st.sidebar.button("Run Analysis"):
+        st.write(f"### Running analysis for: {company_name}")
+
+        with st.spinner("Executing tasks, please wait..."):
+            try:
+                crew = initialize_crew()
+                result = crew.kickoff(inputs={"company": company_name})
+                result_serialized = json.loads(json.dumps(result,cls=CustomJSONEncoder))
+                st.success("Analysis Complete!")
+                st.json(result_serialized)
+
+                pdf_buffer = generate_pdf(result_serialized)
+                st.download_button(
+                    label="📄 Download Report (PDF)",
+                    data=pdf_buffer,
+                    file_name=f"{company_name}_report.pdf",
+                    mime="application/pdf"
+                )
+            except Exception as e:
+                logging.error(f"Error during analysis: {str(e)}")
+                st.error(f"An error occurred: {str(e)}")
+
+if __name__ == "__main__":
+    main()

src/crew_initializer.py

@@ -0,0 +1,44 @@
+from crewai import Crew, Process
+from tasks.competitor_analyst_task import competitor_analyst_task
+from tasks.financial_analyst_task import financial_analyst_task
+from tasks.industry_analyst_task import industry_analyst_task
+from tasks.market_analyst_task import market_analyst_task
+from tasks.swot_analyst_task import swot_analyst_task
+from tasks.reporting_analyst_task import reporting_analyst_task
+from agents.competitor_analyst_agent import competitor_analyst_agent
+from agents.financial_analyst_agent import financial_analyst_agent
+from agents.industry_analyst_agent import industry_analyst_agent
+from agents.market_analyst_agent import market_analyst_agent
+from agents.reporting_analyst_agent import reporting_analyst_agent
+from agents.swot_analyst_agent import swot_analyst_agent
+
+from langchain_openai import ChatOpenAI
+
+def initialize_crew():
+    """
+    Initialize the Crew instance with agents and tasks.
+
+    Returns:
+        Crew: The initialized Crew instance.
+    """
+    return Crew(
+        agents=[
+            industry_analyst_agent,
+            # competitor_analyst_agent,
+            # market_analyst_agent,
+            # financial_analyst_agent,
+            # swot_analyst_agent,
+            # reporting_analyst_agent,
+        ],
+        tasks=[
+            industry_analyst_task,
+            # competitor_analyst_task,
+            # market_analyst_task,
+            # financial_analyst_task,
+            # swot_analyst_task,
+            # reporting_analyst_task
+        ],
+        manager_llm=ChatOpenAI(model="gpt-4o-mini-2024-07-18", temperature=0.7),
+        process=Process.hierarchical,
+        verbose=True
+    )

src/settings.py

@@ -0,0 +1,6 @@
+from src.utils.config_loader import get_config
+
+# Environment configurations
+SERPER_API_KEY = get_config("SERPER_API_KEY")
+GOOGLE_API_KEY = get_config("GOOGLE_API_KEY")
+OPENAI_API_KEY = get_config("OPENAI_API_KEY")

src/tasks/competitor_analyst_task.py

@@ -0,0 +1,16 @@
+from crewai import Task
+from src.agents.competitor_analyst_agent import competitor_analyst_agent
+
+competitor_analyst_task = Task(
+    description=(
+        "Identify key competitors for the company/industry {company}. "
+        "Focus on competitors' business models and market positions."
+    ),
+    expected_output=(
+        "A brief competitor research report that includes:\n"
+        "1. Key competitors of {company}\n"
+        "2. Overview of their market position\n"
+        "3. Similarities and differences in offerings"
+    ),
+    agent=competitor_analyst_agent
+)

src/tasks/financial_analyst_task.py

@@ -0,0 +1,16 @@
+from crewai import Task
+from src.agents.financial_analyst_agent import financial_analyst_agent
+
+financial_analyst_task = Task(
+    description=(
+        "Perform a basic financial analysis of the company {company}. "
+        "Focus on revenue, profit margins, and overall financial health."
+    ),
+    expected_output=(
+        "A summary financial analysis report for {company}, including:\n"
+        "1. Revenue and profit margin overview\n"
+        "2. Key financial ratios\n"
+        "3. Assessment of financial health"
+    ),
+    agent=financial_analyst_agent
+)

src/tasks/industry_analyst_task.py

@@ -0,0 +1,18 @@
+from crewai import Task
+from src.agents.industry_analyst_agent import industry_analyst_agent
+
+industry_analyst_task = Task(
+    description=(
+        "Research and analyze this company/industry {company}. "
+        "Identify key offerings, strategic focus areas, and market position. "
+        "Provide an overview of the industry landscape, including major players and challenges."
+    ),
+    expected_output=(
+        "A summary report on {company}, including:\n"
+        "1. Company/Industry overview\n"
+        "2. Key offerings\n"
+        "3. Strategic focus areas\n"
+        "4. Major competitors"
+    ),
+    agent=industry_analyst_agent
+)

src/tasks/market_analyst_task.py

@@ -0,0 +1,16 @@
+from crewai import Task
+from src.agents.market_analyst_agent import market_analyst_agent
+
+market_analyst_task = Task(
+    description=(
+        "Conduct a market analysis for the company/industry {company}. "
+        "Identify major trends and drivers affecting the industry."
+    ),
+    expected_output=(
+        "A market analysis report for {company}, including:\n"
+        "1. Key market trends\n"
+        "2. Drivers impacting the industry\n"
+        "3. Challenges and opportunities"
+    ),
+    agent=market_analyst_agent
+)

src/tasks/reporting_analyst_task.py

@@ -0,0 +1,26 @@
+from crewai import Task
+from src.agents.reporting_analyst_agent import reporting_analyst_agent
+from src.tasks.industry_analyst_task import industry_analyst_task
+from src.tasks.competitor_analyst_task import competitor_analyst_task
+from src.tasks.market_analyst_task import market_analyst_task
+from src.tasks.financial_analyst_task import financial_analyst_task
+from src.tasks.swot_analyst_task import swot_analyst_task
+
+reporting_analyst_task = Task(
+    description=(
+        "Compile and synthesize data from industry, competitor, market, financial, and SWOT analysts into a comprehensive report. "
+        "Ensure the report is detailed and highlights all key findings."
+    ),
+    expected_output=(
+        "A detailed report that combines industry, competitor, market, financial, and SWOT analysis for {company}, "
+        "highlighting important findings."
+    ),
+    context=[
+        industry_analyst_task,
+        competitor_analyst_task,
+        market_analyst_task,
+        financial_analyst_task,
+        swot_analyst_task
+    ],
+    agent=reporting_analyst_agent
+)

src/tasks/swot_analyst_task.py

@@ -0,0 +1,15 @@
+from crewai import Task
+from src.agents.swot_analyst_agent import swot_analyst_agent
+
+swot_analyst_task = Task(
+    description=(
+        "Conduct a SWOT analysis for the company {company}. "
+        "Summarize strengths, weaknesses, opportunities, and threats."
+    ),
+    expected_output=(
+        "A brief SWOT analysis report for {company}, including:\n"
+        "1. Strengths and weaknesses\n"
+        "2. Opportunities and threats"
+    ),
+    agent=swot_analyst_agent
+)

src/tools/competitorTool.py

@@ -0,0 +1,150 @@
+from crewai_tools import BaseTool
+import pandas as pd
+import numpy as np
+import yfinance as yf
+import yahooquery
+import tensorflow_hub as hub
+import requests
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.cluster import KMeans
+import os
+
+class CompetitorAnalysisTool(BaseTool):
+    name: str = "Competitor Analysis Tool"
+    description: str = "Identify competitors in a specific industry and perform clustering based on business model descriptions."
+
+    def _run(self, company_name: str) -> str:
+
+        def get_ticker(company_name):
+          yfinance = "https://query2.finance.yahoo.com/v1/finance/search"
+          user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36'
+          params = {"q": company_name, "quotes_count": 1, "country": "United States"}
+
+          res = requests.get(url=yfinance, params=params, headers={'User-Agent': user_agent})
+          data = res.json()
+
+          company_code = data['quotes'][0]['symbol']
+          return company_code
+
+
+        """
+            Initialises the class based on the requested company given as a command-line variable.
+            self.ticker is a string representing the ticker symbol for the company.
+            self.info saves all the basic information about the company from the yfinance api.
+            """
+        try:
+                self.ticker = get_ticker(company_name)
+                self.info = yf.Ticker(self.ticker).info
+        except Exception as e:
+                print(e)
+                raise
+
+        def similar_group(self) -> str :
+            """
+            AVAILABLE_SCREENS is a constant that stores the categories that the available stocks are sorted into.
+            In this method, we use the industry of our chosen company and work out which of the categories of stocks best fits the industry.
+            To compute the 'best fit', we encode the screen names and industry name using the Google Universal Sentence Encoder as it captures the semantics of the sentence as well.
+            The method then returns the stocks obtained from the resultant category.
+            """
+            screener = yahooquery.Screener()
+            use_model = hub.KerasLayer("https://tfhub.dev/google/universal-sentence-encoder/4")
+            screeners_embedded = use_model(AVAILABLE_SCREENS)
+            information = pd.DataFrame({'screeners':AVAILABLE_SCREENS, 'embeddings':np.array(x.numpy() for x in screeners_embedded)})
+            industry_vector = use_model([self.info['industry']])[0].numpy()
+            compute_similarity = lambda x: cosine_similarity([x], [industry_vector])[0][0]
+            information['similarity'] = information['embeddings'].map(compute_similarity)
+            maximum_similarity = max(information['similarity'])
+            predicted_screen = information[information['similarity'] == maximum_similarity]
+            return list(predicted_screen['screeners'])[0]
+
+        def identify_market_competition(self) -> pd.DataFrame :
+            """
+            This method processes the result of the similar_group method.
+            The list of stocks obtained from the similar_group method are all potential competitors to our chosen company.
+            So, it collects all companies in a pandas dataframe and attaches the description of the business model of each to the dataframe.
+            This dataframe is then the output of the method.
+            """
+            screener = yahooquery.Screener()
+            most_likely_category = self.similar_group()
+            potential_competition = screener.get_screeners(most_likely_category)[most_likely_category]['quotes']
+            competitor_list = list(x['symbol'] for x in potential_competition)
+            if self.ticker not in competitor_list:
+                competitor_list.append(self.ticker)
+            competitor_list = yahooquery.Ticker(competitor_list)
+            data = pd.DataFrame(competitor_list.asset_profile).T
+            relevent_data = pd.DataFrame(data, columns=['longBusinessSummary'])
+            return relevent_data
+
+        def prepare_clustering_data(self, paragraphs:pd.DataFrame) -> pd.DataFrame :
+            """
+            This method takes as input, the dataframe outputted by the self.identify_market_competition method.
+            The next step is to process the description of the business model but any ML algorithm cannot process string-like data.
+            So, this method uses the Google Universal Sentence Encoder to encode each description as a vector and attaches this to the dataframe.
+            The method then outputs this modified dataframe.
+            """
+            paragraph_embedder = hub.KerasLayer("https://tfhub.dev/google/universal-sentence-encoder/4")
+            business_description_embedded = paragraph_embedder(paragraphs['longBusinessSummary'])
+            paragraphs['summaryEncoded'] = list(x.numpy() for x in business_description_embedded)
+            return paragraphs
+
+        def kmeans_clustering(self, descriptions:pd.DataFrame, clusters:int) -> np.ndarray :
+            """
+            Takes the set of vectors representing the business model and runs a kmeans clustering algorithm to group together similar business descriptions.
+            This method only runs the algorithm for a given number of clusters and this number is optimized in self.get_optimized_labels to maximise information gain.
+            """
+            kmeans_object = KMeans(n_clusters=clusters, random_state=1)
+            kmeans_object.fit(np.array(list(descriptions['summaryEncoded'])))
+            return kmeans_object.labels_
+
+        def get_optimized_labels(self, descriptions:pd.DataFrame, optimisation_range:tuple) -> np.ndarray :
+            """
+            This method runs self.kmeans_clustering on a given range of cluster numbers and works out the optimum number to maximise the quality of clusters.
+            This is done via maximising the silhouette score.
+            The cluster associated with each description is then outputted.
+            """
+            k_values = range(optimisation_range[0], optimisation_range[1])
+            max_silhouette_score = [0,0]
+            for k in k_values:
+                current_labels = self.kmeans_clustering(descriptions, k)
+                silhouette_average = silhouette_score(np.array(list(descriptions['summaryEncoded'])), current_labels)
+                if (silhouette_average > max_silhouette_score[0]):
+                    max_silhouette_score = [silhouette_average, current_labels]
+            return max_silhouette_score[1]
+
+        def obtain_competitors(self, descriptions:pd.DataFrame) -> list :
+            """
+            Runs the kmeans clustering algorithm on potential competitors and ones which are chosen into the same cluster are assumed to have the most similar business model.
+            So, this methods groups together companies in the same cluster as the chosen one and this list is outputted.
+            """
+            if (len(descriptions) <= 5):
+                return list(descriptions.index)
+            max_clusters = int(len(descriptions) / 2) + 1
+            optimum_labels = self.get_optimized_labels(descriptions, (2,max_clusters))
+            descriptions['clusterLabel'] = optimum_labels
+            select_cluster = int(descriptions.loc[self.ticker]['clusterLabel'])
+            selected_competitors = list(descriptions[descriptions['clusterLabel'] == select_cluster].index)
+            selected_competitors.remove(self.ticker)
+            return selected_competitors
+
+        def competitor_analysis_report(self):
+            """
+            Uses the result of self.obtain_competitors and writes a mini summary of results into a text file.
+            """
+            potential_competitors = self.identify_market_competition()
+            revised_competitors = self.prepare_clustering_data(potential_competitors)
+            final_companies = self.obtain_competitors(revised_competitors)
+            ticker_list = yahooquery.Ticker(final_companies)
+            information_dict = ticker_list.quote_type
+            requested_company = yahooquery.Ticker([self.ticker]).quote_type[self.ticker]['shortName']
+            file_name = f"competitionAnalysisReport_{self.ticker}.txt"
+            if len(final_companies) > 0:
+                write_string = f"Requested Company : {requested_company} ({self.ticker})\n\nPossible market competitors in current economic landscape based on business model :\n"
+                count = 1
+                for x in information_dict:
+                    write_string += f"\t{count}. {information_dict[x]['shortName']} ({x})\n"
+                    count += 1
+            else:
+                write_string = f"Requested Company : {requested_company} ({self.ticker})\n\nAlgorithm could not find another major company with noticably similar business models.\nLooks like the company chosen has exploited a gap in the market!"
+            with open(file_name, "w") as f:
+                f.write(write_string)
+        return write_string

src/tools/tools.py

@@ -0,0 +1,30 @@
+
+from crewai_tools import ScrapeWebsiteTool, SerperDevTool,PDFSearchTool
+import os 
+from dotenv import load_dotenv
+from tools.competitorTool import CompetitorAnalysisTool
+
+load_dotenv()
+os.environ['SERPER_API_KEY']=os.getenv('SERPER_API_KEY')
+os.environ['GOOGLE_API_KEY']=os.getenv('GOOGLE_API_KEY')
+pdf_tool = PDFSearchTool(
+    config=dict(
+        llm=dict(
+            provider="google", # or google, openai, anthropic, llama2, ...
+            config=dict(
+                model="gemini-1.5-flash-002",
+
+            ),
+        ),
+        embedder=dict(
+            provider="google", # or openai, ollama, ...
+            config=dict(
+                model="models/embedding-001",
+                task_type="retrieval_document",
+            ),
+        ),
+    ),
+    pdf='.\report.pdf')
+comp_tool = CompetitorAnalysisTool()
+search_tool = SerperDevTool()
+scrape_tool = ScrapeWebsiteTool()

src/utils/config_loader.py

@@ -0,0 +1,18 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from a .env file
+load_dotenv()
+
+def get_config(key: str, default: str = None) -> str:
+    """
+    Retrieve a configuration value from environment variables.
+
+    Args:
+        key (str): The key of the configuration.
+        default (str): The default value if the key is not found.
+
+    Returns:
+        str: The value of the configuration or the default value.
+    """
+    return os.getenv(key, default)

src/utils/pdf_generator.py

@@ -0,0 +1,40 @@
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from io import BytesIO
+import json
+
+def generate_pdf(report_data: dict) -> BytesIO:
+    """
+    Generates a PDF file from the given report data.
+
+    Args:
+        report_data (dict): The data to include in the PDF.
+
+    Returns:
+        BytesIO: A buffer containing the generated PDF.
+    """
+    try:
+        # Create a buffer to store the PDF in memory
+        buffer = BytesIO()
+        c = canvas.Canvas(buffer, pagesize=letter)
+
+        # Set up the text properties
+        text = c.beginText(40, 750)  # Starting position
+        text.setFont("Helvetica", 10)
+
+        # Convert the report data dictionary to a formatted JSON string
+        report_str = json.dumps(report_data, indent=4)
+
+        # Write each line of the JSON string to the PDF
+        for line in report_str.splitlines():
+            text.textLine(line)
+
+        c.drawText(text)
+        c.showPage()
+        c.save()
+
+        # Rewind the buffer to the beginning
+        buffer.seek(0)
+        return buffer
+    except Exception as e:
+        raise RuntimeError(f"Failed to generate PDF: {e}")