add aap.py and added sentiment analysis

.chainlit/config.toml

@@ -0,0 +1,84 @@
+[project]
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+# List of environment variables to be provided by each user to use the app.
+user_env = []
+
+# Duration (in seconds) during which the session is saved when the connection is lost
+session_timeout = 3600
+
+# Enable third parties caching (e.g LangChain cache)
+cache = false
+
+# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
+# follow_symlink = false
+
+[features]
+# Show the prompt playground
+prompt_playground = true
+
+# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
+unsafe_allow_html = false
+
+# Process and display mathematical expressions. This can clash with "$" characters in messages.
+latex = false
+
+# Authorize users to upload files with messages
+multi_modal = true
+
+# Allows user to use speech to text
+[features.speech_to_text]
+    enabled = false
+    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
+    # language = "en-US"
+
+[UI]
+# Name of the app and chatbot.
+name = "Chatbot"
+
+# Show the readme while the conversation is empty.
+show_readme_as_default = true
+
+# Description of the app and chatbot. This is used for HTML tags.
+# description = ""
+
+# Large size content are by default collapsed for a cleaner ui
+default_collapse_content = true
+
+# The default value for the expand messages settings.
+default_expand_messages = false
+
+# Hide the chain of thought details from the user in the UI.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI's header.
+# github = ""
+
+# Specify a CSS file that can be used to customize the user interface.
+# The CSS file can be served from the public directory or via an external link.
+# custom_css = "/public/test.css"
+
+# Override default MUI light theme. (Check theme.ts)
+[UI.theme.light]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.light.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+# Override default MUI dark theme. (Check theme.ts)
+[UI.theme.dark]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.dark.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+
+[meta]
+generated_by = "0.7.700"

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app/
+RUN chown user -R ${HOME}/app/data
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["chainlit", "run", "app.py", "--port", "7860"]

README.md

@@ -0,0 +1 @@
+# StockSavvy

app.py

@@ -0,0 +1,318 @@
+from langchain_experimental.agents import create_pandas_dataframe_agent
+from langchain.llms import OpenAI
+import chainlit as cl
+from plotly.subplots import make_subplots
+import utils as u
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers.openai_functions import JsonOutputFunctionsParser
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from tools import data_analyst
+from tools import stock_sentiment_analysis_util
+import functools
+from typing import Annotated
+import operator
+from typing import Sequence, TypedDict
+from langchain.agents import initialize_agent,  Tool
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langgraph.graph import END, StateGraph
+import numpy as np
+import pandas as pd
+from dotenv import load_dotenv
+import os
+import yfinance as yf
+import functools
+from typing import Annotated
+import operator
+from typing import Sequence, TypedDict
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langgraph.graph import END, StateGraph
+from tools import data_analyst, forecasting_expert_arima, forecasting_expert_rf, evaluator, investment_advisor
+from chainlit.input_widget import Select
+import matplotlib.pyplot as plt
+from langgraph.checkpoint.memory import MemorySaver
+
+load_dotenv()
+OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
+
+from GoogleNews import GoogleNews
+
+def search_news(stockticker):
+    """Useful to search the internet for news about a given topic and return relevant results."""
+    # Set the number of top news results to return
+    googlenews = GoogleNews()
+    googlenews.set_period('7d')
+    googlenews.get_news(stockticker)
+    result_string=googlenews.get_texts()
+
+    return result_string
+
+
+def create_agent(llm: ChatOpenAI, tools: list, system_prompt: str):
+    # Each worker node will be given a name and some tools.
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            (
+                "system",
+                system_prompt,
+            ),
+            MessagesPlaceholder(variable_name="messages"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+    agent = create_openai_tools_agent(llm, tools, prompt)
+    executor = AgentExecutor(agent=agent, tools=tools)
+    return executor
+
+
+def agent_node(state, agent, name):
+    result = agent.invoke(state)
+    return {"messages": [HumanMessage(content=result["output"], name=name)]}
+
+llm = ChatOpenAI(model="gpt-3.5-turbo")
+
+#======================== AGENTS ==================================
+# The agent state is the input to each node in the graph
+class AgentState(TypedDict):
+    # The annotation tells the graph that new messages will always
+    # be added to the current states
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    # The 'next' field indicates where to route to next
+    next: str
+
+# DATA ANALYST
+prompt_data_analyst="You are a stock data analyst.\
+                Provide correct stock ticker from Yahoo Finance.\
+                Expected output: stocticker.\
+                Provide it in the following format: >>stockticker>> \
+                for example: >>AAPL>>"
+                
+tools_data_analyst=data_analyst.data_analyst_tools()
+data_agent = create_agent(
+    llm,
+    tools_data_analyst,
+    prompt_data_analyst)
+get_historical_prices = functools.partial(agent_node, agent=data_agent, name="Data_analyst")
+
+#ARIMA Forecasting expert
+prompt_forecasting_expert_arima="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                You are stock prediction expert, \
+               take historical stock data from message and train the ARIMA model from statsmodels Python library on the last week,then provide prediction for the 'Close' price for the next day.\
+               Give the value for mae_arima to Evaluator.\
+               Expected output:list of predicted prices with predicted dates for a selected stock ticker and mae_arima value.\n
+               <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+tools_forecasting_expert_arima=forecasting_expert_arima.forecasting_expert_arima_tools()
+code_forecasting_arima = create_agent(
+    llm,
+    tools_forecasting_expert_arima,
+    prompt_forecasting_expert_arima,
+)
+predict_future_prices_arima = functools.partial(agent_node, agent=code_forecasting_arima, name="Forecasting_expert_ARIMA")
+
+# RF  Forecasting expert
+prompt_forecasting_expert_random_forest="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                You are stock prediction expert, \
+               take historical stock data from message and train the Random forest model from statsmodels Python library on the last week,then provide prediction for the 'Close' price for the next day.\
+               Give the value for mae_rf to Evaluator.\
+               Expected output:list of predicted prices with predicted dates for a selected stock ticker and mae_rf value.\n
+               <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+tools_forecasting_expert_random_forest=forecasting_expert_rf.forecasting_expert_rf_tools()
+code_forecasting_random_forest = create_agent(
+    llm,
+    tools_forecasting_expert_random_forest,
+    prompt_forecasting_expert_random_forest,
+)
+predict_future_prices_random_forest = functools.partial(agent_node, agent=code_forecasting_random_forest, name="Forecasting_expert_random_forest")
+
+# EVALUATOR
+prompt_evaluator="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                You are an evaluator retrieve arima_prediction and arima mean average error from forecasting expert arima and rf_prediction and mean average error for random forest from forecasting expert random forest\
+                print final prediction number. 
+                Next, compare prediction price and current price to provide reccommendation if he should buy/sell/hold the stock. \
+                 Expected output: one value for the prediction, explain why you have selected this value, reccommendation  buy or sell stock and why.\
+                  <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+tools_evaluate=evaluator.evaluator_tools()
+code_evaluate = create_agent(
+    llm,
+    tools_evaluate,
+    prompt_evaluator,
+)
+evaluate = functools.partial(agent_node, agent=code_evaluate, name="Evaluator")
+
+# Investment advisor
+prompt_inv_advisor="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                Provide personalized investment advice and recommendations and analyze historical stock prices if asked.\
+                Consider user input message for the latest news on the stock.\
+                Provide overall sentiment of the news Positive/Negative/Neutral, and recommend if  the user should invest in such stock.\
+                  <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+tools_reccommend=investment_advisor.investment_advisor_tools()
+
+code_inv_advisor = create_agent(
+    llm,
+    tools_reccommend,
+    prompt_inv_advisor,
+)
+
+reccommend = functools.partial(agent_node, agent=code_inv_advisor, name="Investment_advisor")
+
+workflow_data = StateGraph(AgentState)
+workflow_data.add_node("Data_analyst", get_historical_prices)
+workflow_data.set_entry_point("Data_analyst")
+graph_data=workflow_data.compile()
+
+workflow = StateGraph(AgentState)
+#workflow.add_node("Data_analyst", get_historical_prices)
+workflow.add_node("Forecasting_expert_random_forest", predict_future_prices_random_forest)
+workflow.add_node("Forecasting_expert_ARIMA", predict_future_prices_arima)
+workflow.add_node("Evaluator", evaluate)
+
+
+# Finally, add entrypoint
+workflow.set_entry_point("Forecasting_expert_random_forest")
+workflow.add_edge("Forecasting_expert_random_forest","Forecasting_expert_ARIMA")
+workflow.add_edge("Forecasting_expert_ARIMA","Evaluator")
+workflow.add_edge("Evaluator",END)
+graph = workflow.compile()
+
+#Print graph
+#graph.get_graph().print_ascii()
+
+""" memory = MemorySaver()
+workflow_news = StateGraph(AgentState)
+workflow_news.add_node("Investment_advisor", reccommend)
+workflow_news.set_entry_point("Investment_advisor")
+workflow_news.add_edge("Investment_advisor",END)
+graph_news = workflow_news.compile(checkpointer=memory) """
+
+from langchain_core.runnables import RunnableConfig
+from chainlit import AskUserMessage
+@cl.on_chat_start
+async def on_chat_start():
+    cl.user_session.set("counter", 0)
+    # Sending an image with the local file path
+    elements = [
+    cl.Image(name="image1", display="inline", path="./stock_image1.png",size="large")
+    ]
+    await cl.Message(content="Hello there, Welcome to ##StockSavyy!", elements=elements).send()
+    await cl.Message(content="Tell me the stockticker you want me to analyze.").send()
+
+@cl.on_message
+async def main(message: cl.Message):
+    #"what is the weather in sf"
+    counter = cl.user_session.get("counter")
+    counter += 1
+    cl.user_session.set("counter", counter)
+    await cl.Message(content=f"You sent {counter} message(s)!").send()
+    #if counter==1:
+    inputs = {"messages": [HumanMessage(content=message.content)]}
+    res_data = graph_data.invoke(inputs, config=RunnableConfig(callbacks=[
+        cl.LangchainCallbackHandler(
+            to_ignore=["ChannelRead", "RunnableLambda", "ChannelWrite", "__start__", "_execute"]
+            # can add more into the to_ignore: "agent:edges", "call_model"
+            # to_keep=
+
+        )]))
+    #print(res_data)
+    await cl.Message(content=res_data["messages"][-1].content).send()
+    #print('ticker',str(res_data).split(">>"))
+    if len(str(res_data).split(">>")[1])<10:
+        stockticker=(str(res_data).split(">>")[1])
+    else:
+        stockticker=(str(res_data).split(">>")[0])
+    #print('ticker1',stockticker)
+    print('here')
+    df=u.get_stock_price(stockticker)
+    df_history=u.historical_stock_prices(stockticker,90)
+    df_history_to_msg1=eval(str(list((pd.DataFrame(df_history['Close'].values.reshape(1, -1)[0]).T).iloc[0,:])))
+
+    inputs_all = {"messages": [HumanMessage(content=(f"Predict {stockticker}, historical prices are: {df_history_to_msg1}."))]}
+    df_history=pd.DataFrame(df_history)
+    df_history['stockticker']=np.repeat(stockticker,len(df_history))
+    df_history.to_csv('df_history.csv')
+    #df_history.to_csv('./tools/df_history.csv')
+
+    print ("Running forecasting models on historical prices")
+    res = graph.invoke(inputs_all, config=RunnableConfig(callbacks=[
+        cl.LangchainCallbackHandler(
+            to_ignore=["ChannelRead", "RunnableLambda", "ChannelWrite", "__start__", "_execute"]
+            # can add more into the to_ignore: "agent:edges", "call_model"
+            # to_keep=
+
+        )]))
+    await cl.Message(content= res["messages"][-2].content + '\n\n' + res["messages"][-1].content).send()
+
+    #Plotting the graph
+    df=u.historical_stock_prices(stockticker,90)
+    df=u.calculate_MACD(df, fast_period=12, slow_period=26, signal_period=9)
+    #df values
+    #Index(['Open', 'High', 'Low', 'Close', 'Volume', 'Dividends', 'Stock Splits','EMA_fast', 'EMA_slow', 'MACD', 'Signal_Line', 'MACD_Histogram']
+    fig = u.plot_macd2(df)
+    
+    if fig:
+        elements = [cl.Pyplot(name="plot", figure=fig, display="inline",size="large"),
+        ]
+        await cl.Message(
+            content="Here is the MACD plot",
+            elements=elements,
+        ).send()
+    else:
+        await cl.Message(
+            content="Failed to generate the MACD plot."
+        ).send()
+
+
+    #Perform sentiment analysis on the stock news & predict dominant sentiment along with plotting the sentiment breakdown chart
+    news_articles = stock_sentiment_analysis_util.fetch_news(stockticker)
+
+    analysis_results = []
+    
+    #Perform sentiment analysis for each product review
+    for article in news_articles:
+        sentiment_analysis_result = stock_sentiment_analysis_util.analyze_sentiment(article['News_Article'])
+
+        # Display sentiment analysis results
+        #print(f'News Article: {sentiment_analysis_result["News_Article"]} : Sentiment: {sentiment_analysis_result["Sentiment"]}', '\n')
+
+        result = {
+                    'News_Article': sentiment_analysis_result["News_Article"],
+                    'Sentiment': sentiment_analysis_result["Sentiment"][0]['label']
+                }
+        
+        analysis_results.append(result)
+
+    
+    #Retrieve dominant sentiment based on sentiment analysis data of reviews
+    dominant_sentiment = stock_sentiment_analysis_util.get_dominant_sentiment(analysis_results)
+    await cl.Message(
+            content="Dominant sentiment of the stock based on last 7 days of news is : " + dominant_sentiment
+        ).send()
+    
+    #Plot sentiment breakdown chart
+    
+    fig = stock_sentiment_analysis_util.plot_sentiment_graph(analysis_results)
+    if fig:
+        elements = [cl.Pyplot(name="plot", figure=fig, display="inline",size="large"),
+        ]
+        await cl.Message(
+            content="Sentiment breakdown plot",
+            elements=elements,
+        ).send()
+    else:
+        await cl.Message(
+            content="Failed to generate the MACD plot."
+        ).send()
+    
+    #Generate summarized message rationalize dominant sentiment
+    summary = stock_sentiment_analysis_util.generate_summary_of_sentiment(analysis_results, dominant_sentiment)
+    await cl.Message(
+            content= summary
+        ).send()
+
+
+    
+    

chainlit.md

@@ -0,0 +1 @@
+# Welcome to AskAnyQuery Bot!!

df_history.csv

@@ -0,0 +1,63 @@
+Date,Open,High,Low,Close,Volume,Dividends,Stock Splits,stockticker
+2024-04-22 00:00:00-04:00,399.3596471827562,402.1246793258712,395.03745670124425,400.2380676269531,20286900,0.0,0.0,MSFT
+2024-04-23 00:00:00-04:00,403.51216021293357,407.4650522060062,402.33429210205253,406.836181640625,15734500,0.0,0.0,MSFT
+2024-04-24 00:00:00-04:00,408.82258607970806,411.72735028943725,406.0475926794115,408.323486328125,15065300,0.0,0.0,MSFT
+2024-04-25 00:00:00-04:00,393.32054400787314,399.1700088625431,387.3313470651067,398.321533203125,40586500,0.0,0.0,MSFT
+2024-04-26 00:00:00-04:00,411.4279132786848,412.25640548421114,405.02945064216703,405.58843994140625,29694700,0.0,0.0,MSFT
+2024-04-29 00:00:00-04:00,404.52035539531056,405.5884361925186,398.4712687423875,401.5257568359375,19582100,0.0,0.0,MSFT
+2024-04-30 00:00:00-04:00,400.76710737423014,401.4359144425664,388.4693126899027,388.6289978027344,28781400,0.0,0.0,MSFT
+2024-05-01 00:00:00-04:00,391.9030904630616,400.9967037344784,389.6072438016868,394.2289123535156,23562500,0.0,0.0,MSFT
+2024-05-02 00:00:00-04:00,396.94401914412265,399.20992105581087,393.9394288835304,397.1236877441406,17709400,0.0,0.0,MSFT
+2024-05-03 00:00:00-04:00,401.55570709720826,406.4169339510819,401.13644988960164,405.9278259277344,17446700,0.0,0.0,MSFT
+2024-05-06 00:00:00-04:00,408.024048156178,413.1847226485525,405.63833666603693,412.7954406738281,16996600,0.0,0.0,MSFT
+2024-05-07 00:00:00-04:00,413.91342570011614,413.92341744357753,408.35344694069664,408.6029968261719,20018200,0.0,0.0,MSFT
+2024-05-08 00:00:00-04:00,407.4351142805277,411.48780192255407,405.97772103822234,409.80084228515625,11792300,0.0,0.0,MSFT
+2024-05-09 00:00:00-04:00,409.8307875446534,411.97691043744567,408.363433019907,411.57763671875,14689700,0.0,0.0,MSFT
+2024-05-10 00:00:00-04:00,412.1965086797442,414.6321179246016,411.05854661467066,413.9932556152344,13402300,0.0,0.0,MSFT
+2024-05-13 00:00:00-04:00,417.2573820335048,417.5967662074119,410.08032520369875,412.97509765625,15440200,0.0,0.0,MSFT
+2024-05-14 00:00:00-04:00,411.2781631216723,416.73831581889846,410.8090081198034,415.80999755859375,15109300,0.0,0.0,MSFT
+2024-05-15 00:00:00-04:00,417.8999938964844,423.80999755859375,417.2699890136719,423.0799865722656,22239500,0.75,0.0,MSFT
+2024-05-16 00:00:00-04:00,421.79998779296875,425.4200134277344,420.3500061035156,420.989990234375,17530100,0.0,0.0,MSFT
+2024-05-17 00:00:00-04:00,422.5400085449219,422.9200134277344,418.0299987792969,420.2099914550781,15352200,0.0,0.0,MSFT
+2024-05-20 00:00:00-04:00,420.2099914550781,426.7699890136719,419.989990234375,425.3399963378906,16272100,0.0,0.0,MSFT
+2024-05-21 00:00:00-04:00,426.8299865722656,432.9700012207031,424.8500061035156,429.0400085449219,21453300,0.0,0.0,MSFT
+2024-05-22 00:00:00-04:00,430.0899963378906,432.4100036621094,427.1300048828125,430.5199890136719,18073700,0.0,0.0,MSFT
+2024-05-23 00:00:00-04:00,432.9700012207031,433.6000061035156,425.4200134277344,427.0,17211700,0.0,0.0,MSFT
+2024-05-24 00:00:00-04:00,427.19000244140625,431.05999755859375,424.4100036621094,430.1600036621094,11845800,0.0,0.0,MSFT
+2024-05-28 00:00:00-04:00,429.6300048828125,430.82000732421875,426.6000061035156,430.32000732421875,15718000,0.0,0.0,MSFT
+2024-05-29 00:00:00-04:00,425.69000244140625,430.94000244140625,425.69000244140625,429.1700134277344,15517100,0.0,0.0,MSFT
+2024-05-30 00:00:00-04:00,424.29998779296875,424.29998779296875,414.239990234375,414.6700134277344,28424800,0.0,0.0,MSFT
+2024-05-31 00:00:00-04:00,416.75,416.75,404.510009765625,415.1300048828125,47995300,0.0,0.0,MSFT
+2024-06-03 00:00:00-04:00,415.5299987792969,416.42999267578125,408.9200134277344,413.5199890136719,17484700,0.0,0.0,MSFT
+2024-06-04 00:00:00-04:00,412.42999267578125,416.44000244140625,409.67999267578125,416.07000732421875,14348900,0.0,0.0,MSFT
+2024-06-05 00:00:00-04:00,417.80999755859375,424.0799865722656,416.29998779296875,424.010009765625,16988000,0.0,0.0,MSFT
+2024-06-06 00:00:00-04:00,424.010009765625,425.30999755859375,420.5799865722656,424.5199890136719,14861300,0.0,0.0,MSFT
+2024-06-07 00:00:00-04:00,426.20001220703125,426.2799987792969,423.0,423.8500061035156,13621700,0.0,0.0,MSFT
+2024-06-10 00:00:00-04:00,424.70001220703125,428.0799865722656,423.8900146484375,427.8699951171875,14003000,0.0,0.0,MSFT
+2024-06-11 00:00:00-04:00,425.4800109863281,432.82000732421875,425.25,432.67999267578125,14551100,0.0,0.0,MSFT
+2024-06-12 00:00:00-04:00,435.32000732421875,443.3999938964844,433.25,441.05999755859375,22366200,0.0,0.0,MSFT
+2024-06-13 00:00:00-04:00,440.8500061035156,443.3900146484375,439.3699951171875,441.5799865722656,15960600,0.0,0.0,MSFT
+2024-06-14 00:00:00-04:00,438.2799987792969,443.1400146484375,436.7200012207031,442.57000732421875,13582000,0.0,0.0,MSFT
+2024-06-17 00:00:00-04:00,442.5899963378906,450.94000244140625,440.7200012207031,448.3699951171875,20790000,0.0,0.0,MSFT
+2024-06-18 00:00:00-04:00,449.7099914550781,450.1400146484375,444.8900146484375,446.3399963378906,17112500,0.0,0.0,MSFT
+2024-06-20 00:00:00-04:00,446.29998779296875,446.5299987792969,441.2699890136719,445.70001220703125,19877400,0.0,0.0,MSFT
+2024-06-21 00:00:00-04:00,447.3800048828125,450.5799865722656,446.510009765625,449.7799987792969,34486200,0.0,0.0,MSFT
+2024-06-24 00:00:00-04:00,449.79998779296875,452.75,446.4100036621094,447.6700134277344,15913700,0.0,0.0,MSFT
+2024-06-25 00:00:00-04:00,448.25,451.4200134277344,446.75,450.95001220703125,16747500,0.0,0.0,MSFT
+2024-06-26 00:00:00-04:00,449.0,453.6000061035156,448.19000244140625,452.1600036621094,16507000,0.0,0.0,MSFT
+2024-06-27 00:00:00-04:00,452.17999267578125,456.1700134277344,451.7699890136719,452.8500061035156,14806300,0.0,0.0,MSFT
+2024-06-28 00:00:00-04:00,453.07000732421875,455.3800048828125,446.4100036621094,446.95001220703125,28362300,0.0,0.0,MSFT
+2024-07-01 00:00:00-04:00,448.6600036621094,457.3699951171875,445.6600036621094,456.7300109863281,17662800,0.0,0.0,MSFT
+2024-07-02 00:00:00-04:00,453.20001220703125,459.5899963378906,453.1099853515625,459.2799987792969,13979800,0.0,0.0,MSFT
+2024-07-03 00:00:00-04:00,458.19000244140625,461.0199890136719,457.8800048828125,460.7699890136719,9932800,0.0,0.0,MSFT
+2024-07-05 00:00:00-04:00,459.6099853515625,468.3500061035156,458.9700012207031,467.55999755859375,16000300,0.0,0.0,MSFT
+2024-07-08 00:00:00-04:00,466.54998779296875,467.70001220703125,464.4599914550781,466.239990234375,12962300,0.0,0.0,MSFT
+2024-07-09 00:00:00-04:00,467.0,467.3299865722656,458.0,459.5400085449219,17207200,0.0,0.0,MSFT
+2024-07-10 00:00:00-04:00,461.2200012207031,466.4599914550781,458.8599853515625,466.25,18196100,0.0,0.0,MSFT
+2024-07-11 00:00:00-04:00,462.9800109863281,464.7799987792969,451.54998779296875,454.70001220703125,23111200,0.0,0.0,MSFT
+2024-07-12 00:00:00-04:00,454.3299865722656,456.3599853515625,450.6499938964844,453.54998779296875,16324300,0.0,0.0,MSFT
+2024-07-15 00:00:00-04:00,453.29998779296875,457.260009765625,451.42999267578125,453.9599914550781,14429400,0.0,0.0,MSFT
+2024-07-16 00:00:00-04:00,454.2200012207031,454.29998779296875,446.6600036621094,449.5199890136719,17175700,0.0,0.0,MSFT
+2024-07-17 00:00:00-04:00,442.5899963378906,444.8500061035156,439.17999267578125,443.5199890136719,21778000,0.0,0.0,MSFT
+2024-07-18 00:00:00-04:00,444.3399963378906,444.6499938964844,434.3999938964844,440.3699951171875,20794800,0.0,0.0,MSFT
+2024-07-19 00:00:00-04:00,433.1000061035156,441.1400146484375,432.0,437.1099853515625,20862400,0.0,0.0,MSFT

requirements.txt

@@ -0,0 +1,24 @@
+#langchain
+#chainlit
+#tabulate
+#pandas
+chainlit==0.7.700
+langchain-experimental==0.0.62
+langchain==0.2.7
+langchain_community==0.2.7
+langchain_core==0.2.18
+plotly==5.22.0
+pandas==2.2.2
+yfinance==0.2.40
+langchain-openai==0.1.16
+langgraph==0.1.8
+pydantic==2.8.2
+langchain.tools==0.1.34
+statsmodels==0.14.2
+matplotlib==3.9.1
+python-dotenv==1.0.1
+alpaca_trade_api
+transformers
+pandas
+GoogleNews
+streamlit

tools/.chainlit/config.toml

@@ -0,0 +1,84 @@
+[project]
+# Whether to enable telemetry (default: true). No personal data is collected.
+enable_telemetry = true
+
+# List of environment variables to be provided by each user to use the app.
+user_env = []
+
+# Duration (in seconds) during which the session is saved when the connection is lost
+session_timeout = 3600
+
+# Enable third parties caching (e.g LangChain cache)
+cache = false
+
+# Follow symlink for asset mount (see https://github.com/Chainlit/chainlit/issues/317)
+# follow_symlink = false
+
+[features]
+# Show the prompt playground
+prompt_playground = true
+
+# Process and display HTML in messages. This can be a security risk (see https://stackoverflow.com/questions/19603097/why-is-it-dangerous-to-render-user-generated-html-or-javascript)
+unsafe_allow_html = false
+
+# Process and display mathematical expressions. This can clash with "$" characters in messages.
+latex = false
+
+# Authorize users to upload files with messages
+multi_modal = true
+
+# Allows user to use speech to text
+[features.speech_to_text]
+    enabled = false
+    # See all languages here https://github.com/JamesBrill/react-speech-recognition/blob/HEAD/docs/API.md#language-string
+    # language = "en-US"
+
+[UI]
+# Name of the app and chatbot.
+name = "Chatbot"
+
+# Show the readme while the conversation is empty.
+show_readme_as_default = true
+
+# Description of the app and chatbot. This is used for HTML tags.
+# description = ""
+
+# Large size content are by default collapsed for a cleaner ui
+default_collapse_content = true
+
+# The default value for the expand messages settings.
+default_expand_messages = false
+
+# Hide the chain of thought details from the user in the UI.
+hide_cot = false
+
+# Link to your github repo. This will add a github button in the UI's header.
+# github = ""
+
+# Specify a CSS file that can be used to customize the user interface.
+# The CSS file can be served from the public directory or via an external link.
+# custom_css = "/public/test.css"
+
+# Override default MUI light theme. (Check theme.ts)
+[UI.theme.light]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.light.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+# Override default MUI dark theme. (Check theme.ts)
+[UI.theme.dark]
+    #background = "#FAFAFA"
+    #paper = "#FFFFFF"
+
+    [UI.theme.dark.primary]
+        #main = "#F80061"
+        #dark = "#980039"
+        #light = "#FFE7EB"
+
+
+[meta]
+generated_by = "0.7.700"

tools/chart_expert.py

@@ -0,0 +1,206 @@
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+import yfinance as yf
+from typing import List
+from datetime import datetime,timedelta
+import matplotlib.pyplot as plt
+import chainlit as cl
+import plotly.graph_objects as go
+import pandas as pd
+import yfinance as yf
+from plotly.subplots import make_subplots
+
+def chart_expert_tools(): 
+
+    def historical_stock_prices(stockticker, days_ago):
+        """Upload accurate data to accurate dates from yahoo finance.
+        Receive data on the last week and give them to forecasting experts.
+        Receive data on the last 90 days and give them to visualization expert."""
+        ticker = yf.Ticker(stockticker)
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_ago)
+        start_date = start_date.strftime('%Y-%m-%d')
+        end_date = end_date.strftime('%Y-%m-%d')
+        historical_data = ticker.history(start=start_date, end=end_date)
+        return historical_data
+
+    class HistoricalStockPricesInput(BaseModel):
+        """Input for Stock ticker check."""
+
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        days_ago: int = Field(..., description="Int number of days to look back")
+
+    class HistoricalStockPricesTool(BaseTool):
+        name = "historical_stock_prices"
+        description = "Useful for when you need to find out the historical stock prices. Use Yahoo Finance API to find the correct stockticker."
+
+        def _run(self, stockticker: str, days_ago: int):
+            historical_prices = historical_stock_prices(stockticker, days_ago)
+
+            return {"historical prices":  historical_prices}
+
+        def _arun(self, stockticker: str, days_ago: int):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = HistoricalStockPricesInput
+
+    def calculate_MACD(historical_data, fast_period=12, slow_period=26, signal_period=9):
+        """
+        Calculates the MACD (Moving Average Convergence Divergence) and related indicators.
+
+        Parameters:
+            df (DataFrame): A pandas DataFrame containing at least a 'Close' column with closing prices.
+            fast_period (int): The period for the fast EMA (default is 12).
+            slow_period (int): The period for the slow EMA (default is 26).
+            signal_period (int): The period for the signal line EMA (default is 9).
+
+        Returns:
+            DataFrame: A pandas DataFrame with the original data and added columns for MACD, Signal Line, and MACD Histogram.
+        """
+        df=historical_data[['Close','Open','High','Low']]
+        df['EMA_fast'] = df['Close'].ewm(span=fast_period, adjust=False).mean()
+        df['EMA_slow'] = df['Close'].ewm(span=slow_period, adjust=False).mean()
+        df['MACD'] = df['EMA_fast'] - df['EMA_slow']
+
+        df['Signal_Line'] = df['MACD'].ewm(span=signal_period, adjust=False).mean()
+        df['MACD_Histogram'] = df['MACD'] - df['Signal_Line']
+        return df
+
+
+    class MACDCalculateInput(BaseModel):
+        """Input for Stock ticker check."""
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+
+    class MACDCalculateTool(BaseTool):
+        name = "macd_calculate"
+        description = "Useful for calculating MACD as input for MACD plot."
+
+        def _run(self, stockticker: str, historical_data: float):
+            df = calculate_MACD(historical_data)
+
+            return df
+
+        def _arun(self, stockticker: str, historical_data: float):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = MACDCalculateInput
+
+    def plot_macd(df):
+
+        # Create Figure
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.7, 0.3],
+                            vertical_spacing=0.15,  # Adjust vertical spacing between subplots
+                            subplot_titles=("Candlestick Chart", "MACD"))  # Add subplot titles
+
+
+        # Subplot 1: Plot candlestick chart
+        fig.add_trace(go.Candlestick(
+            x=df.index,
+            open=df['Open'],
+            high=df['High'],
+            low=df['Low'],
+            close=df['Close'],
+            increasing_line_color='#00cc96',  # Green for increasing
+            decreasing_line_color='#ff3e3e',  # Red for decreasing
+            showlegend=False
+        ), row=1, col=1)  # Specify row and column indices
+
+
+        # Subplot 2: Plot MACD
+        fig.add_trace(
+            go.Scatter(
+                x=df.index,
+                y=df['MACD'],
+                mode='lines',
+                name='MACD',
+                line=dict(color='blue')
+            ),
+            row=2, col=1
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=df.index,
+                y=df['Signal_Line'],
+                mode='lines',
+                name='Signal Line',
+                line=dict(color='red')
+            ),
+            row=2, col=1
+        )
+
+        # Plot MACD Histogram with different colors for positive and negative values
+        histogram_colors = ['green' if val >= 0 else 'red' for val in df['MACD_Histogram']]
+
+        fig.add_trace(
+            go.Bar(
+                x=df.index,
+                y=df['MACD_Histogram'],
+                name='MACD Histogram',
+                marker_color=histogram_colors
+            ),
+            row=2, col=1
+        )
+
+        # Update layout with zoom and pan tools enabled
+        layout = go.Layout(
+            title='MSFT Candlestick Chart and MACD Subplots',
+            title_font=dict(size=25),  # Adjust title font size
+            plot_bgcolor='#f2f2f2',  # Light gray background
+            height=800,
+            width=1500,
+            xaxis_rangeslider=dict(visible=True, thickness=0.03),
+        )
+
+        # Update the layout of the entire figure
+        fig.update_layout(layout)
+        fig.update_yaxes(fixedrange=False, row=1, col=1)
+        fig.update_yaxes(fixedrange=True, row=2, col=1)
+        fig.update_xaxes(type='category', row=1, col=1)
+        fig.update_xaxes(type='category', nticks=10, row=2, col=1)
+
+        fig.show()
+
+    class PlotMACDInput(BaseModel):
+        """Input for Stock ticker check."""
+
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        df: List = Field(..., description="List of historical price values")
+        days_ago: int = Field(..., description="Int number of days to look back")
+
+    class PlotMACDTool(BaseTool):
+        name = "plot_macd"
+        description = "Useful for creating beautiful candle stick plot for MACD for a stock price."
+
+        def _run(self, df: List[float]):
+            historical_prices = plot_macd(df)
+
+            return {"historical prices":  historical_prices}
+
+        def _arun(self, df: List[float]):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = PlotMACDInput
+
+
+
+    tools_chart_expert = [StructuredTool.from_function(
+            func=HistoricalStockPricesTool,
+            args_schema=HistoricalStockPricesInput,
+            description="Function to get historical stock prices.",
+        ),
+        StructuredTool.from_function(
+            func=MACDCalculateTool,
+            args_schema=MACDCalculateInput,
+            description="Calculate MACD as  input for MACD plot.",
+        ),
+        StructuredTool.from_function(
+            func=PlotMACDTool,
+            args_schema=PlotMACDInput,
+            description="Plot MACD.",
+        ),
+
+    ]
+    return tools_chart_expert

tools/chart_expert1.py

@@ -0,0 +1,155 @@
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+import yfinance as yf
+from typing import List
+from datetime import datetime,timedelta
+import matplotlib.pyplot as plt
+import chainlit as cl
+import plotly.graph_objects as go
+import pandas as pd
+import yfinance as yf
+from plotly.subplots import make_subplots
+import chainlit as cl
+
+class chart_expert_tools(): 
+
+    def plot_macd(stockticker, days_ago):
+        """Upload accurate data to accurate dates from yahoo finance.
+        Receive data on the last week and give them to forecasting experts.
+        Receive data on the last 90 days and give them to visualization expert."""
+        ticker = yf.Ticker(stockticker)
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_ago)
+        start_date = start_date.strftime('%Y-%m-%d')
+        end_date = end_date.strftime('%Y-%m-%d')
+        historical_data = ticker.history(start=start_date, end=end_date)
+  
+        fast_period=12
+        slow_period=26
+        signal_period=9
+
+        df=historical_data[['Close','Open','High','Low']]
+        df['EMA_fast'] = df['Close'].ewm(span=fast_period, adjust=False).mean()
+        df['EMA_slow'] = df['Close'].ewm(span=slow_period, adjust=False).mean()
+        df['MACD'] = df['EMA_fast'] - df['EMA_slow']
+
+        df['Signal_Line'] = df['MACD'].ewm(span=signal_period, adjust=False).mean()
+        df['MACD_Histogram'] = df['MACD'] - df['Signal_Line']
+
+        # Create Figure
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.7, 0.3],
+                            vertical_spacing=0.15,  # Adjust vertical spacing between subplots
+                            subplot_titles=("Candlestick Chart", "MACD"))  # Add subplot titles
+
+
+        # Subplot 1: Plot candlestick chart
+        fig.add_trace(go.Candlestick(
+            x=df.index,
+            open=df['Open'],
+            high=df['High'],
+            low=df['Low'],
+            close=df['Close'],
+            increasing_line_color='#00cc96',  # Green for increasing
+            decreasing_line_color='#ff3e3e',  # Red for decreasing
+            showlegend=False
+        ), row=1, col=1)  # Specify row and column indices
+
+
+        # Subplot 2: Plot MACD
+        fig.add_trace(
+            go.Scatter(
+                x=df.index,
+                y=df['MACD'],
+                mode='lines',
+                name='MACD',
+                line=dict(color='blue')
+            ),
+            row=2, col=1
+        )
+
+        fig.add_trace(
+            go.Scatter(
+                x=df.index,
+                y=df['Signal_Line'],
+                mode='lines',
+                name='Signal Line',
+                line=dict(color='red')
+            ),
+            row=2, col=1
+        )
+
+        # Plot MACD Histogram with different colors for positive and negative values
+        histogram_colors = ['green' if val >= 0 else 'red' for val in df['MACD_Histogram']]
+
+        fig.add_trace(
+            go.Bar(
+                x=df.index,
+                y=df['MACD_Histogram'],
+                name='MACD Histogram',
+                marker_color=histogram_colors
+            ),
+            row=2, col=1
+        )
+
+        # Update layout with zoom and pan tools enabled
+        layout = go.Layout(
+            title='MSFT Candlestick Chart and MACD Subplots',
+            title_font=dict(size=25),  # Adjust title font size
+            plot_bgcolor='#f2f2f2',  # Light gray background
+            height=800,
+            width=1500,
+            xaxis_rangeslider=dict(visible=True, thickness=0.03),
+        )
+
+        # Update the layout of the entire figure
+        fig.update_layout(layout)
+        fig.update_yaxes(fixedrange=False, row=1, col=1)
+        fig.update_yaxes(fixedrange=True, row=2, col=1)
+        fig.update_xaxes(type='category', row=1, col=1)
+        fig.update_xaxes(type='category', nticks=10, row=2, col=1)
+
+        fig.show()
+        # elements=[
+        #     cl.Pyplot(name="plot", figure=fig, display="inline"),
+        # ]
+
+        # cl.Message(
+        #         content="Ask me anything about stocks.",
+        #         elements=elements,
+        #     ).send()
+        # return elements
+        
+
+    # class PlotMACDInput(BaseModel):
+    #     """Input for Stock ticker check."""
+
+    #     stockticker: str = Field(..., description="Ticker symbol for stock or index")
+    #     days_ago: int = Field(..., description="Int number of days to look back")
+
+    # class PlotMACDTool(BaseTool):
+    #     name = "plot_macd"
+    #     description = "Useful for creating beautiful candle stick plot for MACD for a stock price."
+
+    #     def _run(self, df: List[float]):
+    #         historical_prices = plot_macd(df)
+
+    #         return {"historical prices":  historical_prices}
+
+    #     def _arun(self, df: List[float]):
+    #         raise NotImplementedError("This tool does not support async")
+
+    #     args_schema: Optional[Type[BaseModel]] = PlotMACDInput
+
+
+
+    # tools_chart_expert = [
+    #     StructuredTool.from_function(
+    #         func=PlotMACDTool,
+    #         args_schema=PlotMACDInput,
+    #         description="Plot MACD.",
+    #     ),
+
+    # ]
+    #return tools_chart_expert

tools/data_analyst.py

@@ -0,0 +1,74 @@
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+import yfinance as yf
+from typing import List
+from datetime import datetime,timedelta
+
+def data_analyst_tools():
+    def get_stock_price(stockticker: str) -> str:
+        ticker = yf.Ticker(stockticker)
+        todays_data = ticker.history(period='1d')
+        return str(round(todays_data['Close'][0], 2))
+
+    class StockPriceCheckInput(BaseModel):
+        """Input for Stock price check."""
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+
+    class StockPriceTool(BaseTool):
+        name = "get_stock_ticker_price"
+        description = "Useful for when you need to find out the price of stock. You should input the stock ticker used on the yfinance API"
+        """Input for Stock price check."""
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        def _run(self, stockticker: str):
+            # print("i'm running")
+            price_response = get_stock_price(stockticker)
+
+            return str(price_response)
+
+        def _arun(self, stockticker: str):
+            raise NotImplementedError("This tool does not support async")
+        args_schema: Optional[Type[BaseModel]] = StockPriceCheckInput
+
+    def historical_stock_prices(stockticker, days_ago):
+        ticker = yf.Ticker(stockticker)
+        end_date = datetime.now()
+        start_date = end_date - timedelta(days=days_ago)
+        start_date = start_date.strftime('%Y-%m-%d')
+        end_date = end_date.strftime('%Y-%m-%d')
+        historical_data = ticker.history(start=start_date, end=end_date)
+        return historical_data
+
+    class HistoricalStockPricesInput(BaseModel):
+        """Input for Stock ticker check."""
+
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        days_ago: int = Field(..., description="Int number of days to look back")
+
+    class HistoricalStockPricesTool(BaseTool):
+        name = "historical_stock_prices"
+        description = "Useful for when you need to find out the historical stock prices. Use Yahoo Finance API to find the correct stockticker."
+
+        def _run(self, stockticker: str, days_ago: int):
+            historical_prices = historical_stock_prices(stockticker, days_ago)
+
+            return {"historical prices":  historical_prices}
+
+        def _arun(self, stockticker: str, days_ago: int):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = HistoricalStockPricesInput
+
+    tools_data_analyst = [StructuredTool.from_function(
+            func=StockPriceTool,
+            args_schema=StockPriceCheckInput,
+            description="Function to get current stock prices.",
+        ),
+        # StructuredTool.from_function(
+        #     func=HistoricalStockPricesTool,
+        #     args_schema=HistoricalStockPricesInput,
+        #     description="Function to get historical stock prices.",
+        # )
+    ]
+    return tools_data_analyst

tools/df_history.csv

@@ -0,0 +1,63 @@
+Date,Open,High,Low,Close,Volume,Dividends,Stock Splits,stockticker
+2024-04-22 00:00:00-04:00,399.3596471827562,402.1246793258712,395.03745670124425,400.2380676269531,20286900,0.0,0.0,MSFT
+2024-04-23 00:00:00-04:00,403.51216021293357,407.4650522060062,402.33429210205253,406.836181640625,15734500,0.0,0.0,MSFT
+2024-04-24 00:00:00-04:00,408.82258607970806,411.72735028943725,406.0475926794115,408.323486328125,15065300,0.0,0.0,MSFT
+2024-04-25 00:00:00-04:00,393.32054400787314,399.1700088625431,387.3313470651067,398.321533203125,40586500,0.0,0.0,MSFT
+2024-04-26 00:00:00-04:00,411.4279132786848,412.25640548421114,405.02945064216703,405.58843994140625,29694700,0.0,0.0,MSFT
+2024-04-29 00:00:00-04:00,404.52035539531056,405.5884361925186,398.4712687423875,401.5257568359375,19582100,0.0,0.0,MSFT
+2024-04-30 00:00:00-04:00,400.76710737423014,401.4359144425664,388.4693126899027,388.6289978027344,28781400,0.0,0.0,MSFT
+2024-05-01 00:00:00-04:00,391.9030904630616,400.9967037344784,389.6072438016868,394.2289123535156,23562500,0.0,0.0,MSFT
+2024-05-02 00:00:00-04:00,396.94401914412265,399.20992105581087,393.9394288835304,397.1236877441406,17709400,0.0,0.0,MSFT
+2024-05-03 00:00:00-04:00,401.55570709720826,406.4169339510819,401.13644988960164,405.9278259277344,17446700,0.0,0.0,MSFT
+2024-05-06 00:00:00-04:00,408.024048156178,413.1847226485525,405.63833666603693,412.7954406738281,16996600,0.0,0.0,MSFT
+2024-05-07 00:00:00-04:00,413.91342570011614,413.92341744357753,408.35344694069664,408.6029968261719,20018200,0.0,0.0,MSFT
+2024-05-08 00:00:00-04:00,407.4351142805277,411.48780192255407,405.97772103822234,409.80084228515625,11792300,0.0,0.0,MSFT
+2024-05-09 00:00:00-04:00,409.8307875446534,411.97691043744567,408.363433019907,411.57763671875,14689700,0.0,0.0,MSFT
+2024-05-10 00:00:00-04:00,412.1965086797442,414.6321179246016,411.05854661467066,413.9932556152344,13402300,0.0,0.0,MSFT
+2024-05-13 00:00:00-04:00,417.2573820335048,417.5967662074119,410.08032520369875,412.97509765625,15440200,0.0,0.0,MSFT
+2024-05-14 00:00:00-04:00,411.2781631216723,416.73831581889846,410.8090081198034,415.80999755859375,15109300,0.0,0.0,MSFT
+2024-05-15 00:00:00-04:00,417.8999938964844,423.80999755859375,417.2699890136719,423.0799865722656,22239500,0.75,0.0,MSFT
+2024-05-16 00:00:00-04:00,421.79998779296875,425.4200134277344,420.3500061035156,420.989990234375,17530100,0.0,0.0,MSFT
+2024-05-17 00:00:00-04:00,422.5400085449219,422.9200134277344,418.0299987792969,420.2099914550781,15352200,0.0,0.0,MSFT
+2024-05-20 00:00:00-04:00,420.2099914550781,426.7699890136719,419.989990234375,425.3399963378906,16272100,0.0,0.0,MSFT
+2024-05-21 00:00:00-04:00,426.8299865722656,432.9700012207031,424.8500061035156,429.0400085449219,21453300,0.0,0.0,MSFT
+2024-05-22 00:00:00-04:00,430.0899963378906,432.4100036621094,427.1300048828125,430.5199890136719,18073700,0.0,0.0,MSFT
+2024-05-23 00:00:00-04:00,432.9700012207031,433.6000061035156,425.4200134277344,427.0,17211700,0.0,0.0,MSFT
+2024-05-24 00:00:00-04:00,427.19000244140625,431.05999755859375,424.4100036621094,430.1600036621094,11845800,0.0,0.0,MSFT
+2024-05-28 00:00:00-04:00,429.6300048828125,430.82000732421875,426.6000061035156,430.32000732421875,15718000,0.0,0.0,MSFT
+2024-05-29 00:00:00-04:00,425.69000244140625,430.94000244140625,425.69000244140625,429.1700134277344,15517100,0.0,0.0,MSFT
+2024-05-30 00:00:00-04:00,424.29998779296875,424.29998779296875,414.239990234375,414.6700134277344,28424800,0.0,0.0,MSFT
+2024-05-31 00:00:00-04:00,416.75,416.75,404.510009765625,415.1300048828125,47995300,0.0,0.0,MSFT
+2024-06-03 00:00:00-04:00,415.5299987792969,416.42999267578125,408.9200134277344,413.5199890136719,17484700,0.0,0.0,MSFT
+2024-06-04 00:00:00-04:00,412.42999267578125,416.44000244140625,409.67999267578125,416.07000732421875,14348900,0.0,0.0,MSFT
+2024-06-05 00:00:00-04:00,417.80999755859375,424.0799865722656,416.29998779296875,424.010009765625,16988000,0.0,0.0,MSFT
+2024-06-06 00:00:00-04:00,424.010009765625,425.30999755859375,420.5799865722656,424.5199890136719,14861300,0.0,0.0,MSFT
+2024-06-07 00:00:00-04:00,426.20001220703125,426.2799987792969,423.0,423.8500061035156,13621700,0.0,0.0,MSFT
+2024-06-10 00:00:00-04:00,424.70001220703125,428.0799865722656,423.8900146484375,427.8699951171875,14003000,0.0,0.0,MSFT
+2024-06-11 00:00:00-04:00,425.4800109863281,432.82000732421875,425.25,432.67999267578125,14551100,0.0,0.0,MSFT
+2024-06-12 00:00:00-04:00,435.32000732421875,443.3999938964844,433.25,441.05999755859375,22366200,0.0,0.0,MSFT
+2024-06-13 00:00:00-04:00,440.8500061035156,443.3900146484375,439.3699951171875,441.5799865722656,15960600,0.0,0.0,MSFT
+2024-06-14 00:00:00-04:00,438.2799987792969,443.1400146484375,436.7200012207031,442.57000732421875,13582000,0.0,0.0,MSFT
+2024-06-17 00:00:00-04:00,442.5899963378906,450.94000244140625,440.7200012207031,448.3699951171875,20790000,0.0,0.0,MSFT
+2024-06-18 00:00:00-04:00,449.7099914550781,450.1400146484375,444.8900146484375,446.3399963378906,17112500,0.0,0.0,MSFT
+2024-06-20 00:00:00-04:00,446.29998779296875,446.5299987792969,441.2699890136719,445.70001220703125,19877400,0.0,0.0,MSFT
+2024-06-21 00:00:00-04:00,447.3800048828125,450.5799865722656,446.510009765625,449.7799987792969,34486200,0.0,0.0,MSFT
+2024-06-24 00:00:00-04:00,449.79998779296875,452.75,446.4100036621094,447.6700134277344,15913700,0.0,0.0,MSFT
+2024-06-25 00:00:00-04:00,448.25,451.4200134277344,446.75,450.95001220703125,16747500,0.0,0.0,MSFT
+2024-06-26 00:00:00-04:00,449.0,453.6000061035156,448.19000244140625,452.1600036621094,16507000,0.0,0.0,MSFT
+2024-06-27 00:00:00-04:00,452.17999267578125,456.1700134277344,451.7699890136719,452.8500061035156,14806300,0.0,0.0,MSFT
+2024-06-28 00:00:00-04:00,453.07000732421875,455.3800048828125,446.4100036621094,446.95001220703125,28362300,0.0,0.0,MSFT
+2024-07-01 00:00:00-04:00,448.6600036621094,457.3699951171875,445.6600036621094,456.7300109863281,17662800,0.0,0.0,MSFT
+2024-07-02 00:00:00-04:00,453.20001220703125,459.5899963378906,453.1099853515625,459.2799987792969,13979800,0.0,0.0,MSFT
+2024-07-03 00:00:00-04:00,458.19000244140625,461.0199890136719,457.8800048828125,460.7699890136719,9932800,0.0,0.0,MSFT
+2024-07-05 00:00:00-04:00,459.6099853515625,468.3500061035156,458.9700012207031,467.55999755859375,16000300,0.0,0.0,MSFT
+2024-07-08 00:00:00-04:00,466.54998779296875,467.70001220703125,464.4599914550781,466.239990234375,12962300,0.0,0.0,MSFT
+2024-07-09 00:00:00-04:00,467.0,467.3299865722656,458.0,459.5400085449219,17207200,0.0,0.0,MSFT
+2024-07-10 00:00:00-04:00,461.2200012207031,466.4599914550781,458.8599853515625,466.25,18196100,0.0,0.0,MSFT
+2024-07-11 00:00:00-04:00,462.9800109863281,464.7799987792969,451.54998779296875,454.70001220703125,23111200,0.0,0.0,MSFT
+2024-07-12 00:00:00-04:00,454.3299865722656,456.3599853515625,450.6499938964844,453.54998779296875,16311300,0.0,0.0,MSFT
+2024-07-15 00:00:00-04:00,453.29998779296875,457.260009765625,451.42999267578125,453.9599914550781,14429400,0.0,0.0,MSFT
+2024-07-16 00:00:00-04:00,454.2200012207031,454.29998779296875,446.6600036621094,449.5199890136719,17175700,0.0,0.0,MSFT
+2024-07-17 00:00:00-04:00,442.5899963378906,444.8500061035156,439.17999267578125,443.5199890136719,21778000,0.0,0.0,MSFT
+2024-07-18 00:00:00-04:00,444.3399963378906,444.6499938964844,434.3999938964844,440.3699951171875,20794800,0.0,0.0,MSFT
+2024-07-19 00:00:00-04:00,433.1000061035156,441.1400146484375,432.0,437.1099853515625,20862400,0.0,0.0,MSFT

tools/evaluator.py

@@ -0,0 +1,80 @@
+# EVALUATOR
+import yfinance as yf
+from datetime import datetime, timedelta
+import pandas as pd
+from sklearn.metrics import mean_absolute_error
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+import pandas as pd
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+
+def evaluator_tools():
+    def compare_prediction(mae_rf, mae_arima,prediction_rf,prediction_arima):
+        if mae_rf>mae_arima:
+            result=prediction_arima
+        else:
+            result=prediction_rf
+        return {"final_predicted_outcome": result}#,"mae_rf": mae_rf}
+
+    class compare_predictionInput(BaseModel):
+        """Input for printing final prediction number."""
+        mae_rf: int = Field(..., description="Mean average error for random forest")
+        mae_arima: int = Field(..., description="Mean average error for ARIMA")
+
+        prediction_rf: int = Field(..., description="Price prediction using random forest")
+        prediction_arima: int = Field(..., description="Price prediction using ARIMA")
+
+    class compare_predictionTool(BaseTool):
+        name = "Comparing rf and arima predictions"
+        description = "Useful for showing which predicted outcome is the final result."
+
+        def _run(self, mae_rf=int,mae_arima=int,prediction_rf=int,prediction_arima=int):
+            result = compare_prediction(mae_rf,mae_arima,prediction_rf,prediction_arima)
+            return {"final_predicted_outcome": result}
+
+        def _arun(self, mae_rf=int,mae_arima=int,prediction_rf=int,prediction_arima=int):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = compare_predictionInput
+
+    def buy_or_sell(current_price: float, prediction:float) -> str:
+        if current_price>prediction:
+            position="sell"
+        else:
+            position="buy"
+        return str(position)
+
+    class buy_or_sellInput(BaseModel):
+        """Input for printing final prediction number."""
+        current_price: float = Field(..., description="Current stock price")
+        prediction: float = Field(..., description="Final price prediction from Evaluator")
+
+    class buy_or_sellTool(BaseTool):
+        name = "Comparing current price with prediction"
+        description = """Useful for deciding if to buy/sell stocks based on the prediction result."""
+
+        def _run(self, current_price=float,prediction=float):
+            position = buy_or_sell(current_price,prediction)
+            return {"position": position}
+
+        def _arun(self,current_price=float,prediction=float):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = buy_or_sellInput
+
+    tools_evaluate = [
+        StructuredTool.from_function(
+            func=compare_predictionTool,
+            args_schema=compare_predictionInput,
+            description="Function to evaluate predicted stock prices and print final result.",
+        ),
+        StructuredTool.from_function(
+            func=buy_or_sellTool,
+            args_schema=buy_or_sellInput,
+            description="Function to evaluate client stock position.",
+        ),
+    ]
+    return tools_evaluate

tools/forecasting_expert_arima.py

@@ -0,0 +1,80 @@
+# FORECASTING EXPERT ARIMA TOOLS
+
+from datetime import datetime, timedelta
+import pandas as pd
+from statsmodels.tsa.arima.model import ARIMA
+from sklearn.metrics import mean_absolute_error
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+
+def forecasting_expert_arima_tools():
+    def ARIMA_forecast(symbol,historical_data, train_days_ago, forecast_days):
+            """Useful for forecasting a variable using ARIMA model.
+            Use historical 'Close' stock prices and get prediction.
+            Give prediction output to the client.
+            Give mae_arima from the model to  Evaluator.
+            """
+
+            df=historical_data[['Close']]
+            df.index=pd.to_datetime(df.index)
+            model = ARIMA(df.dropna(), order=(2,0,2))
+            model_fit = model.fit()
+
+            # Split the data into training and testing sets
+            train_size = int(len(df) * 0.8)
+            train, test = df.iloc[:train_size], df.iloc[train_size:]
+
+            # Fit the ARIMA model on the training set
+            model = ARIMA(train.dropna(), order=(2, 0, 2))
+            model_fit = model.fit()
+
+            # Make predictions
+            predictions = model_fit.forecast(steps=len(test))
+            #test['Predicted'] = predictions
+
+            # Calculate the MAE
+            mae_arima = mean_absolute_error(test['Close'], predictions)
+            # plt.plot(y_test, label='Actual')
+            # plt.plot(y_pred, label='Predicted')
+            # plt.legend()
+            # plt.show()
+            forecast = model_fit.get_forecast(forecast_days).predicted_mean
+            arima_prediction=forecast
+            return {"arima_prediction": arima_prediction,"mae_arima": mae_arima}
+
+    class PredictStocksARIMAInput(BaseModel):
+        """Input for Stock ticker check."""
+
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        days_ago: int = Field(..., description="Int number of days to look back")
+
+    class PredictStocksARIMATool(BaseTool):
+        name = "ARIMA_forecast"
+        description = "Useful for forecasting stock prices using ARIMA model."
+
+        def _run(self, stockticker: str, days_ago: int,historical_data: float, train_days_ago=int, forecast_days=int):
+            arima_prediction = ARIMA_forecast(stockticker,historical_data, train_days_ago, forecast_days).predicted_price
+            mae_arima== ARIMA_forecast(stockticker,historical_data, train_days_ago, forecast_days).mae_arima
+
+            return {"arima_prediction":arima_prediction,"mae_arima":mae_arima}
+
+        def _arun(self, stockticker: str, days_ago: int,historical_data: float, train_days_ago=int, forecast_days=int):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = PredictStocksARIMAInput
+
+    tools_forecasting_expert_arima = [
+        StructuredTool.from_function(
+            func=PredictStocksARIMATool,
+            args_schema=PredictStocksARIMAInput,
+            description="Function to predict stock prices with ARIMA model and to get mae_arima for the model.",
+        ),
+        StructuredTool.from_function(
+            func=PredictStocksARIMATool,
+            args_schema=PredictStocksARIMAInput,
+            description="Function to predict stock prices with ARIMA model and to get mae_arima for the model.",
+        )
+    ]
+    return tools_forecasting_expert_arima

tools/forecasting_expert_rf.py

@@ -0,0 +1,105 @@
+# FORECASTING EXPERT RF TOOLS
+
+from datetime import datetime, timedelta
+from sklearn.metrics import mean_absolute_error
+from sklearn.model_selection import train_test_split
+import pandas as pd
+from sklearn.ensemble import RandomForestRegressor
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+
+def forecasting_expert_rf_tools():
+    def RF_forecast(symbol,historical_data, train_days_ago, forecast_days):
+        """Useful for forecasting a variable using ARIMA model.
+        Use historical 'Close' stock prices and get prediction.
+        Give prediction output.
+        Send mae_rf from the model to  Evaluator.
+        """
+        df=historical_data[['Close']]
+        df.index=pd.to_datetime(df.index)
+        df.index.names=['date']
+        end_date = datetime.now()
+
+        df=df.reset_index()
+        # Feature Engineering
+        df['day'] = df['date'].dt.day
+        df['month'] = df['date'].dt.month
+        df['year'] = df['date'].dt.year
+        df['lag1'] = df['Close'].shift(1)
+        df['lag2'] = df['Close'].shift(2)
+        df = df.dropna()
+
+        # Prepare the data
+        features = ['day','month', 'year', 'lag1', 'lag2']
+        X = df[features]
+        y = df['Close']
+
+        # Split the data into training and testing sets
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)
+
+        # Initialize and train the model
+        model = RandomForestRegressor(n_estimators=100, random_state=42)
+        model.fit(X_train, y_train)
+
+        # Make predictions
+        y_pred = model.predict(X_test)
+
+        # Evaluate the model
+        mae_rf = mean_absolute_error(y_test, y_pred)
+        print(f'Mean Absolute Error: {mae_rf}')
+
+        # Forecast future values (next 12 months)
+        future_dates = pd.date_range(start=pd.to_datetime(end_date), end=pd.to_datetime(end_date)+ timedelta(days=forecast_days), freq='D')
+        future_df = pd.DataFrame(future_dates, columns=['date'])
+        future_df['day'] = future_df['date'].dt.day
+        future_df['month'] = future_df['date'].dt.month
+        future_df['year'] = future_df['date'].dt.year
+        future_df['lag1'] = df['Close'].iloc[-1]
+        future_df['lag2'] = df['Close'].iloc[-2]
+
+        # Use the last observed values for lag features
+        for i in range(1, len(future_df)):
+            future_df.loc[future_df.index[i], 'lag1'] = future_df.loc[future_df.index[i-1], 'Close'] if 'Close' in future_df.columns else future_df.loc[future_df.index[i-1], 'lag1']
+            future_df.loc[future_df.index[i], 'lag2'] = future_df.loc[future_df.index[i-1], 'lag1']
+
+        future_X = future_df[features]
+        future_df['Close'] = model.predict(future_X)
+        rf_prediction=future_df['Close']
+        # Print the forecasted values
+        return {"predicted_price": rf_prediction,"mae_rf": mae_rf}
+
+    class PredictStocksRFInput(BaseModel):
+        """Input for Stock ticker check."""
+
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        days_ago: int = Field(..., description="Int number of days to look back")
+
+    class PredictStocksRFTool(BaseTool):
+        name = "Random_forest_forecast"
+        description = "Useful for forecasting stock prices using Random forest model."
+
+        def _run(self, stockticker: str, days_ago: int,historical_data: float, train_days_ago=int, forecast_days=int):
+            predicted_prices = RF_forecast(stockticker,historical_data, train_days_ago, forecast_days).predict_price
+            mae_rf= RF_forecast(stockticker,historical_data, train_days_ago, forecast_days).mae_rf
+            return {"rf_prediction":rf_prediction,"mae_rf":mae_rf}
+
+        def _arun(self, stockticker: str, days_ago: int,historical_data: float, train_days_ago=int, forecast_days=int):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = PredictStocksRFInput
+
+    tools_forecasting_expert_random_forest = [
+        StructuredTool.from_function(
+            func=PredictStocksRFTool,
+            args_schema=PredictStocksRFInput,
+            description="Function to predict stock prices with random forest model and to get mae_rf for the model.",
+        ),
+        StructuredTool.from_function(
+            func=PredictStocksRFTool,
+            args_schema=PredictStocksRFInput,
+            description="Function to predict stock prices with random forest model and to get mae_rf for the model.",
+        ),
+    ]
+    return tools_forecasting_expert_random_forest

tools/investment_advisor.py

@@ -0,0 +1,68 @@
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+import yfinance as yf
+from typing import List
+from datetime import datetime,timedelta
+import pandas as pd
+
+def investment_advisor_tools():
+
+
+    def news_summary(df_search):
+        "Take df_search from the user input message. Summarize news on the selected stockticker and provide Sentiment: positive/negative/neutral to the user."
+        return eval(df_search)
+    
+    class newsSummaryInput(BaseModel):
+        """Input for summarizing articles."""
+        df_search: str = Field(..., description="News articles.")
+
+    class newsSummaryTool(BaseTool):
+        name = "Summarize news on the stockticker"
+        description = """Useful for summarizing the newest article on a selected stockticker."""
+
+        def _run(self, df_search=str):
+            position = news_summary(df_search)
+            return {"position": position}
+
+        def _arun(self,df_search=str):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = newsSummaryInput
+
+    def analyze_prices():
+        """Take historical prices, analyze them and answer user's questions."""
+        df_prices=pd.read_csv('../df_history.csv')
+        return df_prices
+    
+    class pricesInput(BaseModel):
+        """Input for summarizing articles."""
+        stockticker: str = Field(..., description="stockticker name")
+
+    class pricesTool(BaseTool):
+        name = "Get prices from csv file analyze them and answer questions"
+        description = """Useful for analyzing historical stock prices."""
+
+        def _run(self, stockticker=str):
+            df_prices = analyze_prices()
+            return {"prices": df_prices}
+
+        def _arun(self, stockticker=str):
+            raise NotImplementedError("This tool does not support async")
+
+        args_schema: Optional[Type[BaseModel]] = pricesInput
+
+    tools_reccommend = [
+        StructuredTool.from_function(
+            func=newsSummaryTool,
+            args_schema=newsSummaryInput,
+            description="Summarize articles.",
+        ),
+        StructuredTool.from_function(
+            func=pricesTool,
+            args_schema=pricesInput,
+            description="Analyze stock prices.",
+        )
+    ]
+    return tools_reccommend

tools/stock_sentiment_analysis_util.py

@@ -0,0 +1,192 @@
+import requests
+import json
+import os
+from dotenv import load_dotenv
+from transformers import pipeline
+import os
+import pandas as pd
+from collections import defaultdict
+from datetime import date
+import matplotlib.pyplot as plt
+import http.client, urllib.parse
+from GoogleNews import GoogleNews
+from langchain_openai import ChatOpenAI
+
+def fetch_news(stockticker):
+    
+    """ Fetches news articles for a given stock symbol within a specified date range.
+
+    Args:
+    - stockticker (str): Symbol of a particular stock
+    
+    Returns:
+    - list: A list of dictionaries containing stock news. """
+    
+    load_dotenv()
+    days_to_fetch_news = os.environ["DAYS_TO_FETCH_NEWS"]
+
+    googlenews = GoogleNews()
+    googlenews.set_period(days_to_fetch_news)
+    googlenews.get_news(stockticker)
+    news_json=googlenews.get_texts()
+    
+    
+    no_of_news_articles_to_fetch = os.environ["NO_OF_NEWS_ARTICLES_TO_FETCH"]
+    news_article_list = []
+    counter = 0
+    for article in news_json:
+        
+        if(counter >= int(no_of_news_articles_to_fetch)):
+            break
+
+        relevant_info = {
+            'News_Article': article
+        }
+        news_article_list.append(relevant_info)
+        counter+=1
+
+    return news_article_list
+
+
+
+def analyze_sentiment(article):
+    """
+    Analyzes the sentiment of a given news article.
+
+    Args:
+    - news_article (dict): Dictionary containing 'summary', 'headline', and 'created_at' keys.
+
+    Returns:
+    - dict: A dictionary containing sentiment analysis results.
+    """
+
+    #Analyze sentiment using default model
+    #classifier = pipeline('sentiment-analysis')
+
+    #Analyze sentiment using specific model
+    classifier = pipeline(model='mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis')
+    sentiment_result = classifier(str(article))
+
+    analysis_result = {
+        'News_Article': article,
+        'Sentiment': sentiment_result
+    }
+
+    return analysis_result
+
+
+def generate_summary_of_sentiment(sentiment_analysis_results, dominant_sentiment):
+    
+    
+    news_article_sentiment = str(sentiment_analysis_results)
+    print("News article sentiment : " + news_article_sentiment)
+    
+
+    os.environ["OPENAI_API_KEY"] = os.environ["OPENAI_API_KEY"]
+    model = ChatOpenAI(
+        model="gpt-4o",
+        temperature=0,
+        max_tokens=None,
+        timeout=None,
+        max_retries=2,
+        # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
+        # base_url="...",
+        # organization="...",
+        # other params...
+    )
+
+    messages=[
+            {"role": "system", "content": "You are a helpful assistant that looks at all news articles, their sentiment, along with domainant sentiment and generates a summary rationalizing dominant sentiment "},
+            {"role": "user", "content": f"News articles and their sentiments: {news_article_sentiment}, and dominant sentiment is: {dominant_sentiment}"}
+    ]
+    response = model.invoke(messages)
+    
+
+    summary = response.content
+    print ("+++++++++++++++++++++++++++++++++++++++++++++++")
+    print(summary)
+    print ("+++++++++++++++++++++++++++++++++++++++++++++++")
+    return summary
+
+
+def plot_sentiment_graph(sentiment_analysis_results):
+    """
+    Plots a sentiment analysis graph 
+
+    Args:
+    - sentiment_analysis_result): (dict): Dictionary containing 'Review Title : Summary', 'Rating', and 'Sentiment' keys.
+
+    Returns:
+    - dict: A dictionary containing sentiment analysis results.
+    """
+    df = pd.DataFrame(sentiment_analysis_results)
+    print(df)
+
+    #Group by Rating, sentiment value count
+    grouped = df['Sentiment'].value_counts()
+
+    sentiment_counts = df['Sentiment'].value_counts()
+
+    # Plotting pie chart
+    fig = plt.figure(figsize=(8, 8))
+    plt.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', startangle=140)
+    plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.
+    
+    #Open below when u running this program locally and c
+    #plt.show()
+
+    return fig
+
+
+def get_dominant_sentiment (sentiment_analysis_results):
+    """
+    Returns overall sentiment, negative or positive or neutral depending on the count of negative sentiment vs positive sentiment 
+
+    Args:
+    - sentiment_analysis_result): (dict): Dictionary containing 'summary', 'headline', and 'created_at' keys.
+
+    Returns:
+    - dict: A dictionary containing sentiment analysis results.
+    """
+    df = pd.DataFrame(sentiment_analysis_results)
+
+    # Group by the 'sentiment' column and count the occurrences of each sentiment value
+    sentiment_counts = df['Sentiment'].value_counts().reset_index()
+    sentiment_counts.columns = ['sentiment', 'count']
+    print(sentiment_counts)
+
+    # Find the sentiment with the highest count
+    dominant_sentiment = sentiment_counts.loc[sentiment_counts['count'].idxmax()]
+
+    return dominant_sentiment['sentiment']
+
+#starting point of the program
+if __name__ == '__main__':
+    
+    #fetch stock news
+    news_articles = fetch_news('AAPL')
+
+    analysis_results = []
+    
+    #Perform sentiment analysis for each product review
+    for article in news_articles:
+        sentiment_analysis_result = analyze_sentiment(article['News_Article'])
+
+        # Display sentiment analysis results
+        print(f'News Article: {sentiment_analysis_result["News_Article"]} : Sentiment: {sentiment_analysis_result["Sentiment"]}', '\n')
+
+        result = {
+                    'News_Article': sentiment_analysis_result["News_Article"],
+                    'Sentiment': sentiment_analysis_result["Sentiment"][0]['label']
+                }
+        
+        analysis_results.append(result)
+
+    
+    #Graph dominant sentiment based on sentiment analysis data of reviews
+    dominant_sentiment = get_dominant_sentiment(analysis_results)
+    print(dominant_sentiment)
+    
+    #Plot graph
+    plot_sentiment_graph(analysis_results)
+

tools/stock_sentiment_evalutor.py

@@ -0,0 +1,261 @@
+from transformers import pipeline
+from alpaca_trade_api import REST
+import os
+from dotenv import load_dotenv
+from datetime import datetime
+import pandas as pd
+import matplotlib.pyplot as plt
+from datetime import date, timedelta
+from pydantic.v1 import BaseModel, Field
+from langchain.tools import BaseTool
+from typing import Optional, Type
+from langchain.tools import StructuredTool
+
+
+def sentimental_analysis_tools():
+
+    class AlpacaNewsFetcher:
+        """
+        A class for fetching news articles related to a specific stock from Alpaca API.
+
+        Attributes:
+        - api_key (str): Alpaca API key for authentication.
+        - api_secret (str): Alpaca API secret for authentication.
+        - rest_client (alpaca_trade_api.REST): Alpaca REST API client.
+        """
+
+        def __init__(self):
+            """
+            Initializes the AlpacaNewsFetcher object.
+
+            Args:
+            - api_key (str): Alpaca API key for authentication.
+            - api_secret (str): Alpaca API secret for authentication.
+            """
+            load_dotenv()
+            self.api_key = os.environ["ALPACA_API_KEY"]
+            self.api_secret = os.environ["ALPACA_SECRET"]
+            self.rest_client = REST(self.api_key, self.api_secret)
+
+            #No of news articles to fetch for the input stock ticker.
+            self.no_of_newsarticles_to_fetch = os.environ["NO_OF_NEWSARTICLES_TO_FETCH"]
+
+            #No of days to fetch news articles for
+            self.no_of_days = os.environ["NO_OF_DAYS_TO_FETCH_NEWS_ARTICLES"]
+
+
+        def fetch_news(self, stockticker):
+            """
+            Fetches news articles for a given stock symbol within a specified date range.
+
+            Args:
+            - stockticker (str): Stock symbol for which news articles are to be fetched (e.g., "AAPL").
+
+            Returns:
+            - list: A list of dictionaries containing relevant information for each news article.
+            """
+
+            #Date range for which to get the news
+            start_date = date.today()
+            end_date = date.today() - timedelta(self.no_of_days)
+
+            news_articles = self.rest_client.get_news(stockticker, start_date, end_date, limit=self.no_of_newsarticles_to_fetch )
+            formatted_news = []
+
+            for article in news_articles:
+                summary = article.summary
+                title = article.headline
+                timestamp = article.created_at
+
+                relevant_info = {
+                    'timestamp': timestamp,
+                    'title': title,
+                    'summary': summary
+                }
+
+                formatted_news.append(relevant_info)
+
+            return formatted_news
+    
+    
+    class NewsSentimentAnalysis:
+        """
+        A class for sentiment analysis of news articles using the Transformers library.
+
+        Attributes:
+            - classifier (pipeline): Sentiment analysis pipeline from Transformers.
+        """
+
+        def __init__(self):
+            """
+            Initializes the NewsSentimentAnalysis object.
+            """
+            self.classifier = pipeline('sentiment-analysis')
+            
+
+        def analyze_sentiment(self, news_article):
+            """
+            Analyzes the sentiment of a given news article.
+
+            Args:
+            - news_article (dict): Dictionary containing 'summary', 'headline', and 'created_at' keys.
+
+            Returns:
+            - dict: A dictionary containing sentiment analysis results.
+            """
+            summary = news_article['summary']
+            title = news_article['title']
+            timestamp = news_article['timestamp']
+
+            relevant_text = summary + title
+            sentiment_result = self.classifier(relevant_text)
+
+            analysis_result = {
+                'timestamp': timestamp,
+                'title': title,
+                'summary': summary,
+                'sentiment': sentiment_result
+            }
+
+            return analysis_result
+    
+        def plot_sentiment_graph(self, sentiment_analysis_result):
+            """
+            Plots a sentiment analysis graph 
+
+            Args:
+            - sentiment_analysis_result): (dict): Dictionary containing 'summary', 'headline', and 'created_at' keys.
+
+            Returns:
+            - dict: A dictionary containing sentiment analysis results.
+            """
+            df = pd.DataFrame(sentiment_analysis_result)
+            df['Timestamp'] = pd.to_datetime(df['Timestamp'])
+            df['Date'] = df['Timestamp'].dt.date
+
+            #Group by Date, sentiment value count
+            grouped = df.groupby(by='Date')['Sentiment'].value_counts()
+
+            grouped.plot.pie()
+
+        def get_dominant_sentiment (self, sentiment_analysis_result):
+            """
+            Returns overall sentiment, negative or positive or neutral depending on the count of negative sentiment vs positive sentiment 
+
+            Args:
+            - sentiment_analysis_result): (dict): Dictionary containing 'summary', 'headline', and 'created_at' keys.
+
+            Returns:
+            - dict: A dictionary containing sentiment analysis results.
+            """
+            df = pd.DataFrame(sentiment_analysis_result)
+            df['Timestamp'] = pd.to_datetime(df['Timestamp'])
+            df['Date'] = df['Timestamp'].dt.date
+
+            #Group by Date, sentiment value count
+            grouped = df.groupby(by='Date')['Sentiment'].value_counts()
+            df = pd.DataFrame(list(grouped.items()), columns=['Sentiment', 'count'])
+            df['date'] = df['Sentiment'].apply(lambda x: x[0])
+            df['sentiment'] = df['Sentiment'].apply(lambda x: x[1])
+            df.drop('Sentiment', axis=1, inplace=True)
+            result = df.groupby('sentiment')['count'].sum().reset_index()
+            
+            # Determine the sentiment with the most count
+            dominant_sentiment = result.loc[result['count'].idxmax()]
+
+            return dominant_sentiment
+
+
+    #Function to get the stock sentiment
+    def get_stock_sentiment(stockticker: str):
+ 
+        #Initialize AlpacaNewsFetcher, a class for fetching news articles related to a specific stock from Alpaca API.
+        news_fetcher = AlpacaNewsFetcher()
+
+
+        # Fetch news (contains - title of the news, timestamp and summary) for specified stocksticker
+        news_data = news_fetcher.fetch_news(stockticker)
+
+        # Initialize the NewsSentimentAnalysis object
+        news_sentiment_analyzer = NewsSentimentAnalysis()
+        analysis_result = []
+       
+        # Assume 'news_data' is a list of news articles (each as a dictionary), analyze sentiment of each news
+        for article in news_data:
+            sentiment_analysis_result = news_sentiment_analyzer.analyze_sentiment(article)
+
+            # Display sentiment analysis results
+            print(f'Timestamp: {sentiment_analysis_result["timestamp"]}, '
+                f'Title: {sentiment_analysis_result["title"]}, '
+                f'Summary: {sentiment_analysis_result["summary"]}')
+
+            print(f'Sentiment: {sentiment_analysis_result["sentiment"]}', '\n')
+
+            result = {
+                    'Timestamp': sentiment_analysis_result["timestamp"],
+                    'News- Title:Summar': sentiment_analysis_result["title"] + sentiment_analysis_result["summary"],
+                    'Sentiment': sentiment_analysis_result["sentiment"][0]['label']
+                }
+            analysis_result.append(result)
+
+            #Extracting timestamp of article and sentiment of article for graphing
+            """  result_for_graph = {
+                    'Timestamp': sentiment_analysis_result["timestamp"],
+                    'Sentiment': sentiment_analysis_result["sentiment"][0]['label']
+                }
+             
+            analysis_result.append(result_for_graph)
+            """
+
+        #Get dominant sentiment
+        dominant_sentiment = news_sentiment_analyzer.get_dominant_sentiment(sentiment_analysis_result)
+
+        #Build response string for news sentiment
+        output_string = ""
+        for result in analysis_result:
+            output_string = output_string + f'{result["Timestamp"]} : {result["News- Title:Summary"]} : {result["Sentiment"]}' + '\n'
+        
+        final_result = {
+                'Sentiment-analysis-result' : output_string,
+                'Dominant-sentiment' : dominant_sentiment['sentiment']
+        }
+
+        return final_result    
+
+
+    class StockSentimentCheckInput(BaseModel):
+        """Input for Stock price check."""
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+
+    class StockSentimentAnalysisTool(BaseTool):
+        name = "get_stock_sentiment"
+        description = """Useful for finding sentiment of stock, based on published news articles. 
+                        Fetches configured number of news items for the sentiment, 
+                        determines sentiment of each news items and then returns 
+                        List of sentiment analysit result & domainant sentiment of the news
+                        """
+        
+        """Input for Stock sentiment analysis."""
+        stockticker: str = Field(..., description="Ticker symbol for stock or index")
+        def _run(self, stockticker: str):
+            # print("i'm running")
+            sentiment_response = get_stock_sentiment(stockticker)
+            print("++++++++++++++++++++++++++++++++++++++++++++++++++++++")
+            print(str(sentiment_response))
+            print("++++++++++++++++++++++++++++++++++++++++++++++++++++++")
+
+            return sentiment_response
+
+        def _arun(self, stockticker: str):
+            raise NotImplementedError("This tool does not support async")
+        
+        args_schema: Optional[Type[BaseModel]] = StockSentimentCheckInput
+
+
+    tools_sentiment_analyst = [StructuredTool.from_function(
+            func=StockSentimentAnalysisTool,
+            args_schema=StockSentimentCheckInput,
+            description="Function to get stock sentiment.",
+        )
+    ]
+    return tools_sentiment_analyst

utils.py

@@ -0,0 +1,178 @@
+import matplotlib.pyplot as plt
+import chainlit as cl
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import yfinance as yf
+from plotly.subplots import make_subplots
+
+def get_stock_price(stockticker: str) -> str:
+        ticker = yf.Ticker(stockticker)
+        todays_data = ticker.history(period='1d')
+        return str(round(todays_data['Close'][0], 2))
+
+def plot_candlestick_stock_price(historical_data):
+    """Useful for plotting candlestick plot for stock prices.
+    Use historical stock price data from yahoo finance for the week and plot them."""
+    df=historical_data[['Close','Open','High','Low']]
+    df.index=pd.to_datetime(df.index)
+    df.index.names=['Date']
+    df=df.reset_index()
+
+    fig = go.Figure(data=[go.Candlestick(x=df['Date'],
+                open=df['Open'],
+                high=df['High'],
+                low=df['Low'],
+                close=df['Close'])])
+    fig.show()
+
+def historical_stock_prices(stockticker, days_ago):
+    """Upload accurate data to accurate dates from yahoo finance."""
+    ticker = yf.Ticker(stockticker)
+    end_date = datetime.now()
+    start_date = end_date - timedelta(days=days_ago)
+    start_date = start_date.strftime('%Y-%m-%d')
+    end_date = end_date.strftime('%Y-%m-%d')
+    historical_data = ticker.history(start=start_date, end=end_date)
+    return historical_data
+
+def plot_macd2(df):
+    try:
+        # Debugging: Print the dataframe columns and a few rows
+        print("DataFrame columns:", df.columns)
+        print("DataFrame head:\n", df.head())
+
+        # Convert DataFrame index and columns to numpy arrays
+        index = df.index.to_numpy()
+        close_prices = df['Close'].to_numpy()
+        macd = df['MACD'].to_numpy()
+        signal_line = df['Signal_Line'].to_numpy()
+        macd_histogram = df['MACD_Histogram'].to_numpy()
+
+        fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(10, 8), gridspec_kw={'height_ratios': [3, 1]})
+
+        # Subplot 1: Candlestick chart
+        ax1.plot(index, close_prices, label='Close', color='black')
+        ax1.set_title("Candlestick Chart")
+        ax1.set_ylabel("Price")
+        ax1.legend()
+
+        # Subplot 2: MACD
+        ax2.plot(index, macd, label='MACD', color='blue')
+        ax2.plot(index, signal_line, label='Signal Line', color='red')
+
+        histogram_colors = np.where(macd_histogram >= 0, 'green', 'red')
+        ax2.bar(index, macd_histogram, color=histogram_colors, alpha=0.6)
+
+        ax2.set_title("MACD")
+        ax2.set_ylabel("MACD Value")
+        ax2.legend()
+
+        plt.xlabel("Date")
+        plt.tight_layout()
+
+        return fig
+    except Exception as e:
+        print(f"Error in plot_macd: {e}")
+        return None
+
+def plot_macd(df):
+
+    # Create Figure
+    fig = make_subplots(rows=2, cols=1, shared_xaxes=True, row_heights=[0.2, 0.1],
+                        vertical_spacing=0.15,  # Adjust vertical spacing between subplots
+                        subplot_titles=("Candlestick Chart", "MACD"))  # Add subplot titles
+
+
+    # Subplot 1: Plot candlestick chart
+    fig.add_trace(go.Candlestick(
+        x=df.index,
+        open=df['Open'],
+        high=df['High'],
+        low=df['Low'],
+        close=df['Close'],
+        increasing_line_color='#00cc96',  # Green for increasing
+        decreasing_line_color='#ff3e3e',  # Red for decreasing
+        showlegend=False
+    ), row=1, col=1)  # Specify row and column indices
+
+
+    # Subplot 2: Plot MACD
+    fig.add_trace(
+        go.Scatter(
+            x=df.index,
+            y=df['MACD'],
+            mode='lines',
+            name='MACD',
+            line=dict(color='blue')
+        ),
+        row=2, col=1
+    )
+
+    fig.add_trace(
+        go.Scatter(
+            x=df.index,
+            y=df['Signal_Line'],
+            mode='lines',
+            name='Signal Line',
+            line=dict(color='red')
+        ),
+        row=2, col=1
+    )
+
+    # Plot MACD Histogram with different colors for positive and negative values
+    histogram_colors = ['green' if val >= 0 else 'red' for val in df['MACD_Histogram']]
+
+    fig.add_trace(
+        go.Bar(
+            x=df.index,
+            y=df['MACD_Histogram'],
+            name='MACD Histogram',
+            marker_color=histogram_colors
+        ),
+        row=2, col=1
+    )
+
+    # Update layout with zoom and pan tools enabled
+    layout = go.Layout(
+        title='MSFT Candlestick Chart and MACD Subplots',
+        title_font=dict(size=12),  # Adjust title font size
+        plot_bgcolor='#f2f2f2',  # Light gray background
+        height=600,
+        width=1200,
+        xaxis_rangeslider=dict(visible=True, thickness=0.03),
+    )
+
+    # Update the layout of the entire figure
+    fig.update_layout(layout)
+    fig.update_yaxes(fixedrange=False, row=1, col=1)
+    fig.update_yaxes(fixedrange=True, row=2, col=1)
+    fig.update_xaxes(type='category', row=1, col=1)
+    fig.update_xaxes(type='category', nticks=10, row=2, col=1)
+    
+    fig.show()
+    #return fig
+
+def calculate_MACD(df, fast_period=12, slow_period=26, signal_period=9):
+    """
+    Calculates the MACD (Moving Average Convergence Divergence) and related indicators.
+
+    Parameters:
+        df (DataFrame): A pandas DataFrame containing at least a 'Close' column with closing prices.
+        fast_period (int): The period for the fast EMA (default is 12).
+        slow_period (int): The period for the slow EMA (default is 26).
+        signal_period (int): The period for the signal line EMA (default is 9).
+
+    Returns:
+        DataFrame: A pandas DataFrame with the original data and added columns for MACD, Signal Line, and MACD Histogram.
+    """
+
+    df['EMA_fast'] = df['Close'].ewm(span=fast_period, adjust=False).mean()
+    df['EMA_slow'] = df['Close'].ewm(span=slow_period, adjust=False).mean()
+    df['MACD'] = df['EMA_fast'] - df['EMA_slow']
+
+    df['Signal_Line'] = df['MACD'].ewm(span=signal_period, adjust=False).mean()
+    df['MACD_Histogram'] = df['MACD'] - df['Signal_Line']
+
+    return df