Push all the changes to Hugging Face

README.md

@@ -1,7 +1,7 @@
 # Chatbot using Langchain and Chainlit
 
 ```bash
-git clone git@github.com:sanjeevl10/StockSavvyFinal.git
+git clone https://github.com/amalaj7/Chatbot-using-Langchain-Chainlit.git
 ```
 Install dependencies
 ```bash

app.py

@@ -1,228 +1,172 @@
-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
-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 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
-from chainlit.input_widget import Select
-from langchain_core.runnables import RunnableConfig
-import matplotlib.pyplot as plt
-
-load_dotenv()
-
-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.\
-                 Expected output: one value for the prediction, explain why you have selected this value.\
-                  <|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")
-
-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")
-graph = workflow.compile()
-
-@cl.on_chat_start
-async def on_chat_start():
-
-    # Sending an image with the local file path
-    elements = [
-    cl.Image(name="image1", display="inline", path="./good_day.jpg",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"
-    
-    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)
-    
-    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,:])))
-    df_history_to_msg=dict(df_history.reset_index()['Close'])
-    #print('here',eval(str(list(((df_history['Close']))))))
-
-    # print('dict',dict(df_history.reset_index()['Close']))
-    #print('tady',str(list((pd.DataFrame(df_history['Close'].values.reshape(1, -1)[0]).T).iloc[0,:])))
-    #print('heere',df_history_to_msg1)
-
-    #inputs_all = {"messages": [HumanMessage(content=("Predict Aaple, historical prices are: {172.45608520507812, 169.15057373046875, 167.77244567871094, 166.81373596191406, 164.77650451660156, 165.6153564453125, 166.67391967773438, 168.7910614013672"))]}   #,df_history_to_msg))]}
-    #print(f"Predict {stockticker}, historical prices are: {df_history_to_msg1}")
-    inputs_all = {"messages": [HumanMessage(content=(f"Predict {stockticker}, historical prices are: {df_history_to_msg1}"))]}
-    #print(inputs_all)
-
-    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"][-1].content).send()
-    # await cl.Message(content=df).send()
-    # print(res)
-    # print(str(res).split('>>')[0])
-    
-    #print('here',str(res).split('>>')[0].split("n")[-1].split("'")[-1])
-    #stockticker=(str(inputs['messages']).split('=')[1].split("'")[1])
-    print('stockticker',stockticker)
-
-    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,str(stockticker))
-    
-    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()
-
-
-    
+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, stock_sentiment_evalutor, forecasting_expert_arima, forecasting_expert_rf, evaluator, investment_advisor
+import functools
+from typing import Annotated, Sequence, TypedDict
+from langgraph.graph import END, StateGraph
+import operator
+import numpy as np
+import pandas as pd
+from dotenv import load_dotenv
+import os
+import yfinance as yf
+from chainlit.input_widget import Select
+import matplotlib.pyplot as plt
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.runnables import RunnableConfig
+
+
+load_dotenv()
+OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
+
+from GoogleNews import GoogleNews
+
+def search_news(stockticker):
+    googlenews = GoogleNews()
+    googlenews.set_period('7d')
+    googlenews.get_news(stockticker)
+    return googlenews.get_texts()
+
+def create_agent(llm: ChatOpenAI, tools: list, system_prompt: str):
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            MessagesPlaceholder(variable_name="messages"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+    agent = create_openai_tools_agent(llm, tools, prompt)
+    return AgentExecutor(agent=agent, tools=tools)
+
+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 ==================================
+class AgentState(TypedDict):
+    messages: Annotated[Sequence[BaseMessage], operator.add]
+    next: str
+
+# Data Analyst
+prompt_data_analyst = "You are a stock data analyst. Provide correct stock ticker from Yahoo Finance. Expected output: stockticker. 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 = "system You are a 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. assistant"
+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 = "system You are a 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. assistant"
+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 = "system 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 recommendation if he should buy/sell/hold the stock. Expected output: one value for the prediction, explain why you have selected this value, recommendation buy or sell stock and why. assistant"
+tools_evaluate = evaluator.evaluator_tools()
+code_evaluate = create_agent(llm, tools_evaluate, prompt_evaluator)
+evaluate = functools.partial(agent_node, agent=code_evaluate, name="Evaluator")
+
+# Stock Sentiment Evaluator
+prompt_sentiment_evaluator = "system You are a stock sentiment evaluator. Retrieve news for the stock based on the configured data range starting today and their corresponding sentiment, along with the most dominant sentiment for the stock. Expected output: List ALL stock news and their sentiment from the StockSentimentAnalysis tool response, and the dominant sentiment for the stock also in StockSentimentAnalysis tool response as is without change. assistant"
+tools_sentiment_evaluator = stock_sentiment_evalutor.sentimental_analysis_tools()
+sentiment_evaluator = create_agent(llm, tools_sentiment_evaluator, prompt_sentiment_evaluator)
+evaluate_sentiment = functools.partial(agent_node, agent=sentiment_evaluator, name="Sentiment_Evaluator")
+
+# Investment Advisor
+prompt_inv_advisor = "system Provide personalized investment advice and recommendations. 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. MUST finish the analysis with a summary on the latest news from the user input on the stock! assistant"
+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("Forecasting_expert_random_forest", predict_future_prices_random_forest)
+workflow.add_node("Forecasting_expert_ARIMA", predict_future_prices_arima)
+workflow.add_node("Evaluator", evaluate)
+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()
+
+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)
+
+@cl.on_chat_start
+async def on_chat_start():
+    cl.user_session.set("counter", 0)
+    elements = [cl.Image(name="image1", display="inline", path="./stock_image1.png", size="large")]
+    await cl.Message(content="Welcome to ##StockSavvy!", elements=elements).send()
+    await cl.Message(content="Enter a Company Name for Stock Recommendations from Our Chatbot").send()
+
+@cl.on_message
+async def main(message: cl.Message):
+    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"]
+            )]))
+        await cl.Message(content=res_data["messages"][-1].content).send()
+
+        stockticker = (str(res_data).split(">>")[1] if len(str(res_data).split(">>")[1]) < 10 else str(res_data).split(">>")[0])
+        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')
+
+        res = graph.invoke(inputs_all, config=RunnableConfig(callbacks=[
+            cl.LangchainCallbackHandler(
+                to_ignore=["ChannelRead", "RunnableLambda", "ChannelWrite", "__start__", "_execute"]
+            )]))
+        await cl.Message(content=res["messages"][-2].content + '\n\n' + res["messages"][-1].content).send()
+
+    df_history = pd.read_csv('df_history.csv')
+    stockticker = str(df_history['stockticker'][0])
+    df_search = search_news(stockticker)
+    with open('search_news.txt', 'w') as a:
+        a.write(str(df_search[0:10]))
+    with open("search_news.txt", "r") as file:
+        df_search = file.read()
+
+    inputs_news = {"messages": [HumanMessage(content=(f"Summarize articles for {stockticker} to write 2 sentences about following articles: {df_search}."))]}
+    for event in graph_news.stream(inputs_news, {"configurable": {"thread_id": "1"}}, stream_mode="values"):
+        await cl.Message(content=event["messages"][-1].content).send()
+
+    if counter == 1:
+        df = u.historical_stock_prices(stockticker, 90)
+        df = u.calculate_MACD(df, fast_period=12, slow_period=26, signal_period=9)
+        fig = u.plot_macd2(df)
+        elements = [cl.Pyplot(name="plot", figure=fig, display="inline", size="large")] if fig else []
+        await cl.Message(content="Here is the MACD plot" if fig else "Failed to generate the MACD plot.", elements=elements).send()

app_test3_memory.py

@@ -0,0 +1,303 @@
+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_evalutor
+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, stock_sentiment_evalutor, 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")
+
+#Stock Sentiment Evaluator
+prompt_sentiment_evaluator="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                You are a stock sentiment evaluator, that takes in a stock ticker and 
+                then using your StockSentimentAnalysis tool retrieve news for the stock based on the configured data range starting today and their corresponding sentiment,
+                alongwith the most dominant sentiment for the stock\
+                Expected output: List ALL stock news and their sentiment from the StockSentimentAnalysis tool response, and the dominant sentiment for the stock also in StockSentimentAnalysis tool response as is without change\
+                Also ensure you use the tool only once and do not make changes to messages
+                Also you are not to change the response from the tool\
+                  <|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+tools_sentiment_evaluator=stock_sentiment_evalutor.sentimental_analysis_tools()
+sentiment_evaluator = create_agent(
+    llm,
+    tools_sentiment_evaluator,
+    prompt_sentiment_evaluator,
+)
+evaluate_sentiment = functools.partial(agent_node, agent=sentiment_evaluator, name="Sentiment_Evaluator")
+
+# Investment advisor
+prompt_inv_advisor="""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+                Provide personalized investment advice and recommendations.\
+                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.\
+                MUST finish the analysis with a summary on the latest news from the user input on the 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
+@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}."))]}
+        #print(inputs_all)
+        df_history=pd.DataFrame(df_history)
+        df_history['stockticker']=np.repeat(stockticker,len(df_history))
+        df_history.to_csv('df_history.csv')
+
+        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()
+        
+    df_history=pd.read_csv('df_history.csv')
+    stockticker=str(df_history['stockticker'][0])
+    df_search=search_news(stockticker)
+    with open('search_news.txt', 'w') as a:
+            a.write(str(df_search[0:10]))
+    file = open("search_news.txt", "r")
+    df_search = file.read()
+    print(stockticker)
+
+    config = {"configurable": {"thread_id": "1"}}
+    inputs_news = {"messages": [HumanMessage(content=(f"Summarize articles for {stockticker} to write 2 sentences about following articles: {df_search}."))]}
+    k=0
+    for event in graph_news.stream(inputs_news, config, stream_mode="values"):
+            k+=1
+            if k>1:
+                await cl.Message(content=event["messages"][-1].content).send()
+        
+
+    if counter==1:
+        df=u.historical_stock_prices(stockticker,90)
+        df=u.calculate_MACD(df, fast_period=12, slow_period=26, signal_period=9)
+        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()
+
+
+
+    

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,176.94000244140625,178.8699951171875,174.55999755859375,177.22999572753906,37924900,0.0,0.0,AMZN
+2024-04-23 00:00:00-04:00,178.0800018310547,179.92999267578125,175.97999572753906,179.5399932861328,37046500,0.0,0.0,AMZN
+2024-04-24 00:00:00-04:00,179.94000244140625,180.32000732421875,176.17999267578125,176.58999633789062,34185100,0.0,0.0,AMZN
+2024-04-25 00:00:00-04:00,169.67999267578125,173.9199981689453,166.32000732421875,173.6699981689453,49249400,0.0,0.0,AMZN
+2024-04-26 00:00:00-04:00,177.8000030517578,180.82000732421875,176.1300048828125,179.6199951171875,43919800,0.0,0.0,AMZN
+2024-04-29 00:00:00-04:00,182.75,183.52999877929688,179.38999938964844,180.9600067138672,54063900,0.0,0.0,AMZN
+2024-04-30 00:00:00-04:00,181.08999633789062,182.99000549316406,174.8000030517578,175.0,94639800,0.0,0.0,AMZN
+2024-05-01 00:00:00-04:00,181.63999938964844,185.14999389648438,176.55999755859375,179.0,94645100,0.0,0.0,AMZN
+2024-05-02 00:00:00-04:00,180.85000610351562,185.10000610351562,179.91000366210938,184.72000122070312,54303500,0.0,0.0,AMZN
+2024-05-03 00:00:00-04:00,186.99000549316406,187.8699951171875,185.4199981689453,186.2100067138672,39172000,0.0,0.0,AMZN
+2024-05-06 00:00:00-04:00,186.27999877929688,188.75,184.8000030517578,188.6999969482422,34725300,0.0,0.0,AMZN
+2024-05-07 00:00:00-04:00,188.9199981689453,189.94000244140625,187.30999755859375,188.75999450683594,34048900,0.0,0.0,AMZN
+2024-05-08 00:00:00-04:00,187.44000244140625,188.42999267578125,186.38999938964844,188.0,26136400,0.0,0.0,AMZN
+2024-05-09 00:00:00-04:00,188.8800048828125,191.6999969482422,187.44000244140625,189.5,43368400,0.0,0.0,AMZN
+2024-05-10 00:00:00-04:00,189.16000366210938,189.88999938964844,186.92999267578125,187.47999572753906,34141800,0.0,0.0,AMZN
+2024-05-13 00:00:00-04:00,188.0,188.30999755859375,185.36000061035156,186.57000732421875,24898600,0.0,0.0,AMZN
+2024-05-14 00:00:00-04:00,183.82000732421875,187.72000122070312,183.4499969482422,187.07000732421875,38698200,0.0,0.0,AMZN
+2024-05-15 00:00:00-04:00,185.97000122070312,186.72000122070312,182.72999572753906,185.99000549316406,75459900,0.0,0.0,AMZN
+2024-05-16 00:00:00-04:00,185.60000610351562,187.30999755859375,183.4600067138672,183.6300048828125,38834500,0.0,0.0,AMZN
+2024-05-17 00:00:00-04:00,183.75999450683594,185.3000030517578,183.35000610351562,184.6999969482422,33175700,0.0,0.0,AMZN
+2024-05-20 00:00:00-04:00,184.33999633789062,186.6699981689453,183.27999877929688,183.5399932861328,30511800,0.0,0.0,AMZN
+2024-05-21 00:00:00-04:00,182.3000030517578,183.25999450683594,180.75,183.14999389648438,50839100,0.0,0.0,AMZN
+2024-05-22 00:00:00-04:00,183.8800048828125,185.22000122070312,181.97000122070312,183.1300048828125,28148800,0.0,0.0,AMZN
+2024-05-23 00:00:00-04:00,183.66000366210938,184.75999450683594,180.0800018310547,181.0500030517578,33670200,0.0,0.0,AMZN
+2024-05-24 00:00:00-04:00,181.64999389648438,182.44000244140625,180.3000030517578,180.75,27434100,0.0,0.0,AMZN
+2024-05-28 00:00:00-04:00,179.92999267578125,182.24000549316406,179.49000549316406,182.14999389648438,29927000,0.0,0.0,AMZN
+2024-05-29 00:00:00-04:00,181.6999969482422,184.0800018310547,181.5500030517578,182.02000427246094,32009300,0.0,0.0,AMZN
+2024-05-30 00:00:00-04:00,181.30999755859375,181.33999633789062,178.36000061035156,179.32000732421875,29249200,0.0,0.0,AMZN
+2024-05-31 00:00:00-04:00,178.3000030517578,179.2100067138672,173.8699951171875,176.44000244140625,58903900,0.0,0.0,AMZN
+2024-06-03 00:00:00-04:00,177.6999969482422,178.6999969482422,175.9199981689453,178.33999633789062,30786600,0.0,0.0,AMZN
+2024-06-04 00:00:00-04:00,177.63999938964844,179.82000732421875,176.44000244140625,179.33999633789062,27198400,0.0,0.0,AMZN
+2024-06-05 00:00:00-04:00,180.10000610351562,181.5,178.75,181.27999877929688,32116400,0.0,0.0,AMZN
+2024-06-06 00:00:00-04:00,181.75,185.0,181.49000549316406,185.0,31371200,0.0,0.0,AMZN
+2024-06-07 00:00:00-04:00,184.89999389648438,186.2899932861328,183.36000061035156,184.3000030517578,28021500,0.0,0.0,AMZN
+2024-06-10 00:00:00-04:00,184.07000732421875,187.22999572753906,183.7899932861328,187.05999755859375,34494500,0.0,0.0,AMZN
+2024-06-11 00:00:00-04:00,187.05999755859375,187.77000427246094,184.5399932861328,187.22999572753906,27265100,0.0,0.0,AMZN
+2024-06-12 00:00:00-04:00,188.02000427246094,188.35000610351562,185.42999267578125,186.88999938964844,33984200,0.0,0.0,AMZN
+2024-06-13 00:00:00-04:00,186.08999633789062,187.6699981689453,182.6699981689453,183.8300018310547,39721500,0.0,0.0,AMZN
+2024-06-14 00:00:00-04:00,183.0800018310547,183.72000122070312,182.22999572753906,183.66000366210938,25456400,0.0,0.0,AMZN
+2024-06-17 00:00:00-04:00,182.52000427246094,185.0,181.22000122070312,184.05999755859375,35601900,0.0,0.0,AMZN
+2024-06-18 00:00:00-04:00,183.74000549316406,184.2899932861328,181.42999267578125,182.80999755859375,36659200,0.0,0.0,AMZN
+2024-06-20 00:00:00-04:00,182.91000366210938,186.50999450683594,182.72000122070312,186.10000610351562,44726800,0.0,0.0,AMZN
+2024-06-21 00:00:00-04:00,187.8000030517578,189.27999877929688,185.86000061035156,189.0800018310547,72931800,0.0,0.0,AMZN
+2024-06-24 00:00:00-04:00,189.3300018310547,191.0,185.3300018310547,185.57000732421875,50610400,0.0,0.0,AMZN
+2024-06-25 00:00:00-04:00,186.80999755859375,188.83999633789062,185.4199981689453,186.33999633789062,45898500,0.0,0.0,AMZN
+2024-06-26 00:00:00-04:00,186.9199981689453,194.8000030517578,186.25999450683594,193.61000061035156,65103900,0.0,0.0,AMZN
+2024-06-27 00:00:00-04:00,195.00999450683594,199.83999633789062,194.1999969482422,197.85000610351562,74397500,0.0,0.0,AMZN
+2024-06-28 00:00:00-04:00,197.72999572753906,198.85000610351562,192.5,193.25,76930200,0.0,0.0,AMZN
+2024-07-01 00:00:00-04:00,193.49000549316406,198.3000030517578,192.82000732421875,197.1999969482422,41192000,0.0,0.0,AMZN
+2024-07-02 00:00:00-04:00,197.27999877929688,200.42999267578125,195.92999267578125,200.0,45600000,0.0,0.0,AMZN
+2024-07-03 00:00:00-04:00,199.94000244140625,200.02999877929688,196.75999450683594,197.58999633789062,31597900,0.0,0.0,AMZN
+2024-07-05 00:00:00-04:00,198.64999389648438,200.5500030517578,198.1699981689453,200.0,39858900,0.0,0.0,AMZN
+2024-07-08 00:00:00-04:00,200.0399932861328,201.1999969482422,197.9600067138672,199.2899932861328,34767300,0.0,0.0,AMZN
+2024-07-09 00:00:00-04:00,199.39999389648438,200.57000732421875,199.0500030517578,199.33999633789062,32700100,0.0,0.0,AMZN
+2024-07-10 00:00:00-04:00,200.0,200.11000061035156,197.69000244140625,199.7899932861328,32883800,0.0,0.0,AMZN
+2024-07-11 00:00:00-04:00,200.08999633789062,200.27000427246094,192.86000061035156,195.0500030517578,44565000,0.0,0.0,AMZN
+2024-07-12 00:00:00-04:00,194.8000030517578,196.47000122070312,193.8300018310547,194.49000549316406,30598500,0.0,0.0,AMZN
+2024-07-15 00:00:00-04:00,194.55999755859375,196.19000244140625,190.8300018310547,192.72000122070312,40683200,0.0,0.0,AMZN
+2024-07-16 00:00:00-04:00,195.58999633789062,196.6199951171875,192.24000549316406,193.02000427246094,33994700,0.0,0.0,AMZN
+2024-07-17 00:00:00-04:00,191.35000610351562,191.5800018310547,185.99000549316406,187.92999267578125,48076100,0.0,0.0,AMZN
+2024-07-18 00:00:00-04:00,189.58999633789062,189.67999267578125,181.4499969482422,183.75,51043600,0.0,0.0,AMZN
+2024-07-19 00:00:00-04:00,181.13999938964844,184.92999267578125,180.11000061035156,183.1300048828125,42994700,0.0,0.0,AMZN

historicalprices.py

@@ -0,0 +1,36 @@
+import requests
+from bs4 import BeautifulSoup
+import re
+
+def get_historical_prices(product_url):
+    headers = {
+        'User-Agent': 'Your User Agent'
+    }
+    response = requests.get(product_url, headers=headers)
+    
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.content, 'html.parser')
+        price_data = {}
+        
+        # Extract historical price data
+        price_blocks = soup.find_all('div', class_='price-history__row')
+        
+        for block in price_blocks:
+            date = block.find('span', class_='price-history__date').text.strip()
+            price = block.find('span', class_='price-history__price').text.strip()
+            price_data[date] = price
+            
+        return price_data
+    else:
+        print(f"Failed to retrieve data. Status code: {response.status_code}")
+        return None
+
+# Example usage
+if __name__ == '__main__':
+    product_url = 'https://camelcamelcamel.com/product/ASIN'
+    historical_prices = get_historical_prices(product_url)
+    
+    if historical_prices:
+        print("Historical Prices:")
+        for date, price in historical_prices.items():
+            print(f"{date}: {price}")

requirements.txt

@@ -11,7 +11,7 @@ plotly==5.22.0
 pandas==2.2.2
 yfinance==0.2.40
 langchain-openai==0.1.16
-langgraph==0.1.18
+langgraph==0.1.8
 pydantic==2.8.2
 langchain.tools==0.1.34
 statsmodels==0.14.2
@@ -19,4 +19,5 @@ matplotlib==3.9.1
 python-dotenv==1.0.1
 alpaca_trade_api
 transformers
-pandas
+googlenews
+

search_news.txt

@@ -0,0 +1 @@
+['Investing in Amazon Stock (AMZN)', 'Amazon.com, Inc. (NASDAQ:AMZN) Shares Could Be 40% Below Their Intrinsic Value Estimate', 'Why Amazon Stock Is the Biggest Bargain After Amazon Prime Day', 'Is Amazon Stock A Buy As Analysts Project Strong Prime Day Sales?', "Amazon cracks down on 'coffee badging' employees by tracking individual hours spent in the office", 'Amazon Stock (AMZN) Price Prediction and Forecast 2025-2030', 'Amazon CEO Andy Jassy says being ‘ravenous’ about one thing will determine if your career is a success', 'Amazon says this year’s Prime Day was its biggest ever', 'Amazon Prime Day 2024 returns this July', '4 stocks to watch on Thursday: NFLX, AMZN and more']

tools/evaluator.py

@@ -40,11 +40,41 @@ def evaluator_tools():
 
         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/investment_advisor.py

@@ -0,0 +1,42 @@
+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 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
+
+
+
+    tools_reccommend = [
+        StructuredTool.from_function(
+            func=newsSummaryTool,
+            args_schema=newsSummaryInput,
+            description="Summarize articles.",
+        )
+    ]
+    return tools_reccommend

tools/stock_sentiment_evalutor.py

@@ -1,5 +1,4 @@
 from transformers import pipeline
-from client import AlpacaNewsFetcher
 from alpaca_trade_api import REST
 import os
 from dotenv import load_dotenv
@@ -7,7 +6,7 @@ from datetime import datetime
 import pandas as pd
 import matplotlib.pyplot as plt
 from datetime import date, timedelta
-from pydantic import BaseModel, Field
+from pydantic.v1 import BaseModel, Field
 from langchain.tools import BaseTool
 from typing import Optional, Type
 from langchain.tools import StructuredTool
@@ -130,7 +129,6 @@ def sentimental_analysis_tools():
             Returns:
             - dict: A dictionary containing sentiment analysis results.
             """
-            print(sentiment_analysis_result)
             df = pd.DataFrame(sentiment_analysis_result)
             df['Timestamp'] = pd.to_datetime(df['Timestamp'])
             df['Date'] = df['Timestamp'].dt.date
@@ -170,7 +168,7 @@ def sentimental_analysis_tools():
 
     #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()
 
@@ -211,9 +209,14 @@ def sentimental_analysis_tools():
 
         #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' : analysis_result,
+                'Sentiment-analysis-result' : output_string,
                 'Dominant-sentiment' : dominant_sentiment['sentiment']
         }
 
@@ -237,6 +240,9 @@ def sentimental_analysis_tools():
         def _run(self, stockticker: str):
             # print("i'm running")
             sentiment_response = get_stock_sentiment(stockticker)
+            print("++++++++++++++++++++++++++++++++++++++++++++++++++++++")
+            print(str(sentiment_response))
+            print("++++++++++++++++++++++++++++++++++++++++++++++++++++++")
 
             return sentiment_response
 

utils.py

@@ -28,9 +28,7 @@ def plot_candlestick_stock_price(historical_data):
     fig.show()
 
 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."""
+    """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)