DEV Community

Zane
Zane

Posted on

Building a High-Quality Stock Report Generator with Node.js, Express, and OpenAI API

In this article, we will delve into creating a professional-grade stock report generator using Node.js, Express, and the OpenAI API. The application will fetch stock data, perform sentiment and industry analysis, and generate a comprehensive investment report.

Table of Contents

  1. Project Overview
  2. Setting Up the Environment
  3. Creating the Express Server
  4. Fetching and Processing Data
  5. Integrating with OpenAI API
  6. Generating the Final Report
  7. Testing the Application
  8. Conclusion

Project Overview

Our goal is to build an API endpoint that generates a detailed investment report for a given stock ticker. The report will include:

  • Company Overview
  • Financial Performance
  • Management Discussion and Analysis (MDA)
  • Sentiment Analysis
  • Industry Analysis
  • Risks and Opportunities
  • Investment Recommendation

We will fetch stock data from external APIs and use the OpenAI API for advanced analysis, ensuring that the prompt messages are accurately preserved.

Setting Up the Environment

Prerequisites

  • Node.js installed on your machine
  • OpenAI API Key (If you don't have one, sign up at OpenAI)

Initializing the Project

Create a new directory and initialize a Node.js project:

mkdir stock-report-generator
cd stock-report-generator
npm init -y
Enter fullscreen mode Exit fullscreen mode

Install the necessary dependencies:

npm install express axios
Enter fullscreen mode Exit fullscreen mode

Set up the project structure:

mkdir routes utils data
touch app.js routes/report.js utils/helpers.js
Enter fullscreen mode Exit fullscreen mode

Creating the Express Server

Setting Up app.js

// app.js
const express = require('express');
const reportRouter = require('./routes/report');

const app = express();

app.use(express.json());
app.use('/api', reportRouter);

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});
Enter fullscreen mode Exit fullscreen mode
  • Express Initialization: Import Express and initialize the application.
  • Middleware: Use express.json() to parse JSON request bodies.
  • Routing: Mount the report router on the /api path.
  • Server Listening: Start the server on the specified port.

Fetching and Processing Data

Creating Helper Functions

In utils/helpers.js, we'll define utility functions for data fetching and processing.

// utils/helpers.js
const axios = require('axios');
const fs = require('fs');
const path = require('path');

const BASE_URL = 'https://your-data-api.com'; // Replace with your actual data API

/**
 * Get the start and end dates for the last year.
 * @returns {object} - An object containing `start` and `end` dates.
 */
function getLastYearDates() {
  const now = new Date();
  const end = now.toISOString().split('T')[0];
  now.setFullYear(now.getFullYear() - 1);
  const start = now.toISOString().split('T')[0];
  return { start, end };
}

/**
 * Convert an object to a string, excluding specified keys.
 * @param {object} obj - The object to convert.
 * @param {string[]} excludeKeys - Keys to exclude.
 * @returns {string} - The resulting string.
 */
function objectToString(obj, excludeKeys = []) {
  return Object.entries(obj)
    .filter(([key]) => !excludeKeys.includes(key))
    .map(([key, value]) => `${key}: ${value}`)
    .join('\n');
}

/**
 * Fetch data from a specified endpoint with given parameters.
 * @param {string} endpoint - API endpoint.
 * @param {object} params - Query parameters.
 * @param {any} defaultValue - Default value if the request fails.
 * @returns {Promise<any>} - The fetched data or default value.
 */
async function fetchData(endpoint, params = {}, defaultValue = null) {
  try {
    const response = await axios.get(`${BASE_URL}${endpoint}`, { params });
    return response.data || defaultValue;
  } catch (error) {
    console.error(`Error fetching data from ${endpoint}:`, error.message);
    return defaultValue;
  }
}

/**
 * Read data from a local JSON file.
 * @param {string} fileName - Name of the JSON file.
 * @returns {any} - The parsed data.
 */
function readLocalJson(fileName) {
  const filePath = path.join(__dirname, '../data', fileName);
  const data = fs.readFileSync(filePath, 'utf-8');
  return JSON.parse(data);
}

module.exports = {
  fetchData,
  objectToString,
  getLastYearDates,
  readLocalJson,
};
Enter fullscreen mode Exit fullscreen mode
  • getLastYearDates: Calculates the start and end dates for the previous year.
  • objectToString: Converts an object to a readable string, excluding specified keys.
  • fetchData: Handles GET requests to external APIs, returning data or a default value.
  • readLocalJson: Reads data from local JSON files.

Implementing Stock Data Fetching

In routes/report.js, define functions to fetch stock data.

// routes/report.js
const express = require('express');
const {
  fetchData,
  objectToString,
  getLastYearDates,
  readLocalJson,
} = require('../utils/helpers');

const router = express.Router();

/**
 * Fetches stock data including historical prices, financials, MDA, and main business info.
 * @param {string} ticker - Stock ticker symbol.
 * @returns {Promise<object>} - An object containing all fetched data.
 */
async function fetchStockData(ticker) {
  try {
    const dates = getLastYearDates();
    const [historicalData, financialData, mdaData, businessData] = await Promise.all([
      fetchData('/stock_zh_a_hist', {
        symbol: ticker,
        period: 'weekly',
        start_date: dates.start,
        end_date: dates.end,
      }, []),

      fetchData('/stock_financial_benefit_ths', {
        code: ticker,
        indicator: '按年度',
      }, [{}]),

      fetchData('/stock_mda', { code: ticker }, []),

      fetchData('/stock_main_business', { code: ticker }, []),
    ]);

    const hist = historicalData[historicalData.length - 1];
    const currentPrice = (hist ? hist['开盘'] : 'N/A') + ' CNY';
    const historical = historicalData
      .map((item) => objectToString(item, ['股票代码']))
      .join('\n----------\n');

    const zsfzJson = readLocalJson('zcfz.json');
    const balanceSheet = objectToString(zsfzJson.find((item) => item['股票代码'] === ticker));

    const financial = objectToString(financialData[0]);

    const mda = mdaData.map(item => `${item['报告期']}\n${item['内容']}`).join('\n-----------\n');

    const mainBusiness = businessData.map(item =>
      `主营业务: ${item['主营业务']}\n产品名称: ${item['产品名称']}\n产品类型: ${item['产品类型']}\n经营范围: ${item['经营范围']}`
    ).join('\n-----------\n');

    return { currentPrice, historical, balanceSheet, mda, mainBusiness, financial };
  } catch (error) {
    console.error('Error fetching stock data:', error.message);
    throw error;
  }
}
Enter fullscreen mode Exit fullscreen mode
  • fetchStockData: Concurrently fetches multiple data points and processes the results.
  • Data Processing: Formats and transforms data for subsequent use.
  • Error Handling: Logs errors and rethrows them for higher-level handling.

Integrating with OpenAI API

OpenAI API Interaction Function

const axios = require('axios');

const OPENAI_API_KEY = 'your-openai-api-key'; // Replace with your OpenAI API key

/**
 * Interacts with the OpenAI API to get completion results.
 * @param {array} messages - Array of messages, including system prompts and user messages.
 * @returns {Promise<string>} - The AI's response.
 */
async function analyzeWithOpenAI(messages) {
  try {
    const headers = {
      'Authorization': `Bearer ${OPENAI_API_KEY}`,
      'Content-Type': 'application/json',
    };
    const requestData = {
      model: 'gpt-4',
      temperature: 0.3,
      messages: messages,
    };

    const response = await axios.post(
      'https://api.openai.com/v1/chat/completions',
      requestData,
      { headers }
    );
    return response.data.choices[0].message.content.trim();
  } catch (error) {
    console.error('Error fetching analysis from OpenAI:', error.message);
    throw error;
  }
}
Enter fullscreen mode Exit fullscreen mode
  • analyzeWithOpenAI: Handles communication with the OpenAI API.
  • API Configuration: Sets parameters such as model and temperature.
  • Error Handling: Logs and throws errors for upstream handling.

Performing Sentiment Analysis

/**
 * Performs sentiment analysis on news articles using the OpenAI API.
 * @param {string} ticker - Stock ticker symbol.
 * @returns {Promise<string>} - Sentiment analysis summary.
 */
async function performSentimentAnalysis(ticker) {
  const systemPrompt = `You are a sentiment analysis assistant. Analyze the sentiment of the given news articles for ${ticker} and provide a summary of the overall sentiment and any notable changes over time. Be measured and discerning. You are a skeptical investor.`;

  const tickerNewsResponse = await fetchData('/stock_news_specific', { code: ticker }, []);

  const newsText = tickerNewsResponse
    .map(item => `${item['文章来源']} Date: ${item['发布时间']}\n${item['新闻内容']}`)
    .join('\n----------\n');

  const messages = [
    { role: 'system', content: systemPrompt },
    {
      role: 'user',
      content: `News articles for ${ticker}:\n${newsText || 'N/A'}\n----\nProvide a summary of the overall sentiment and any notable changes over time.`,
    },
  ];

  return await analyzeWithOpenAI(messages);
}
Enter fullscreen mode Exit fullscreen mode
  • performSentimentAnalysis: Constructs prompt messages and calls the OpenAI API for analysis.
  • Prompt Design: Ensures that the prompt messages are clear and include necessary context.

Analyzing the Industry

/**
 * Analyzes industry information using the OpenAI API.
 * @param {string} industry - Industry name.
 * @returns {Promise<string>} - Industry analysis summary.
 */
async function analyzeIndustry(industry) {
  const industryNewsResponse = await fetchData('/stock_news_specific', { code: industry }, []);
  const industryNewsArticles = industryNewsResponse
    .map(item => `${item['文章来源']} Date: ${item['发布时间']}\n${item['新闻内容']}`)
    .join('\n----------\n');

  const systemPrompt = `You are an industry analysis assistant. Provide an analysis of the ${industry} industry, including trends, growth prospects, regulatory changes, and competitive landscape.

Consider the following recent news articles relevant to the ${industry} industry:
${industryNewsArticles || 'N/A'}

Be measured and discerning. Truly think about the positives and negatives of the industry. Be sure of your analysis. You are a skeptical investor.`;

  const messages = [
    { role: 'system', content: systemPrompt },
    {
      role: 'user',
      content: `Provide an analysis of the ${industry} industry, taking into account the recent news articles provided.`,
    },
  ];

  return await analyzeWithOpenAI(messages);
}
Enter fullscreen mode Exit fullscreen mode
  • analyzeIndustry: Similar to sentiment analysis but focuses on broader industry context.
  • Prompt Preservation: Maintains the integrity of the original prompt messages.

Generating the Final Report

Compiling All Data

/**
 * Generates the final investment report.
 * @param {string} ticker - Stock ticker symbol.
 * @param {object} data - Collected data and analyses.
 * @returns {Promise<string>} - The final report.
 */
async function provideFinalAnalysis(ticker, data) {
  const {
    sentimentAnalysis,
    industryAnalysis,
    balanceSheet,
    mda,
    mainBusiness,
    financial,
    currentPrice,
    historical,
  } = data;

  const systemPrompt = `You are a financial analyst tasked with providing a comprehensive investment recommendation for the stock ${ticker}. Your analysis should utilize the available data and aim for a length of approximately 1500 to 3000 words. Focus on the following key aspects:

1. **Company Overview**: Provide a brief overview of the company, including its business model, core products/services, and market position. Refer to the provided main business data.

2. **Financial Performance**:
   - Analyze key financial metrics based on the available data, including the current price (${currentPrice}), historical data, financial data, and balance sheet.
   - Highlight any significant financial trends and changes.

3. **Management Discussion and Analysis (MDA)**:
   - Summarize the management's insights and future outlook based on the provided MDA data.

4. **Sentiment Analysis**:
   - Summarize public sentiment based on recent news articles.
   - Include insights into any significant events or announcements that could influence market perception.

5. **Industry Analysis**:
   - Outline current industry trends and major players based on the available industry data.
   - Identify any regulatory or technological factors affecting the industry.

6. **Macroeconomic Factors**:
   - Analyze relevant macroeconomic indicators that may impact the company's performance.

7. **Risks and Opportunities**:
   - Identify key risks facing the company, including market, operational, and regulatory risks.
   - Highlight potential growth opportunities and strategic initiatives.

8. **Investment Recommendation**:
   - Based on your analysis, provide a clear recommendation (buy, hold, or sell) for the stock.
   - Support your recommendation with a well-reasoned rationale, considering both positives and negatives.

Please write in a professional tone, using precise language and relevant financial terminology. Respond in Chinese.`;

  const userPrompt = `Ticker: ${ticker}\n
1. **Sentiment Analysis**:\n${sentimentAnalysis}\n
2. **Industry Analysis**:\n${industryAnalysis}\n
3. **Financial Data**:\nCurrent Price: ${currentPrice}\nHistorical Data: ${historical}\nBalance Sheet: ${balanceSheet}\nFinancial Data: ${financial}\n
4. **Management Discussion and Analysis (MDA)**:\n${mda}\n
5. **Main Business**:\n${mainBusiness}\n\n
Based on the provided data and analyses, please provide a comprehensive investment analysis and recommendation for ${ticker}. Ensure the report length is controlled between 1500 and 3000 words, ensuring clarity and conciseness in your arguments.`;

  const messages = [
    { role: 'system', content: systemPrompt },
    {
      role: 'user',
      content: userPrompt,
    },
  ];

  return await analyzeWithOpenAI(messages);
}
Enter fullscreen mode Exit fullscreen mode
  • provideFinalAnalysis: Carefully crafts prompt messages, incorporating all collected data.
  • Prompt Integrity: Ensures that the original prompt messages are not altered or corrupted.

Testing the Application

Defining the Route Handler

Add the route handler in routes/report.js:

router.post('/generate-report', async (req, res) => {
  const { ticker } = req.body;

  if (!ticker) {
    return res.status(400).json({ error: 'Ticker symbol is required.' });
  }

  try {
    const dataJson = readLocalJson('stock.json');
    const stockInfo = dataJson.find((item) => item.symbol === ticker);

    if (!stockInfo) {
      return res.status(404).json({ error: 'Stock information not found.' });
    }

    const { industry } = stockInfo;

    // Fetch stock data
    const stockData = await fetchStockData(ticker);

    // Perform analyses
    const [sentimentAnalysis, industryAnalysis] = await Promise.all([
      performSentimentAnalysis(ticker),
      analyzeIndustry(industry || 'the industry'),
    ]);

    // Generate final report
    const finalAnalysis = await provideFinalAnalysis(ticker, {
      sentimentAnalysis,
      industryAnalysis,
      ...stockData,
    });

    res.json({ report: finalAnalysis });
  } catch (error) {
    console.error('Error generating report:', error.message);
    res.status(500).json({ error: 'Failed to generate report.' });
  }
});

module.exports = router;
Enter fullscreen mode Exit fullscreen mode
  • Input Validation: Checks if the ticker symbol is provided.
  • Data Gathering: Concurrently fetches stock data and performs analyses.
  • Error Handling: Logs errors and sends a 500 response in case of failure.

Starting the Server

Ensure your app.js and routes/report.js are correctly set up, then start the server:

node app.js
Enter fullscreen mode Exit fullscreen mode

Sending a Test Request

Use curl or Postman to send a POST request:

curl -X POST http://localhost:3000/api/generate-report \
  -H 'Content-Type: application/json' \
  -d '{"ticker": "AAPL"}'
Enter fullscreen mode Exit fullscreen mode
  • Response: The server should return a JSON object containing the generated report.

Conclusion

We have built a high-quality stock report generator with the following capabilities:

  • Fetching and processing stock data from external APIs.
  • Performing advanced analyses using the OpenAI API.
  • Generating a comprehensive investment report, while ensuring the integrity of the prompt messages.

Throughout the development process, we focused on writing professional, maintainable code and provided detailed explanations and annotations.

Best Practices Implemented

  • Modular Code Structure: Functions are modularized for reusability and clarity.
  • Asynchronous Operations: Used async/await and Promise.all for efficient asynchronous programming.
  • Error Handling: Comprehensive try-catch blocks and error messages.
  • API Abstraction: Separated API interaction logic for better maintainability.
  • Prompt Engineering: Carefully designed prompt messages for the OpenAI API to achieve the desired output.
  • Input Validation: Checked for required input parameters to prevent unnecessary errors.
  • Code Documentation: Added JSDoc comments for better understanding and maintenance.

Next Steps

  • Caching: Implement caching mechanisms to reduce redundant API calls.
  • Authentication: Secure the API endpoints with authentication and rate limiting.
  • Frontend Development: Build a user interface for interacting with the application.
  • Additional Analyses: Incorporate technical analysis or other financial models.

References


Disclaimer: This application is for educational purposes only. Ensure compliance with all API terms of service and handle sensitive data appropriately.

Top comments (0)