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. Our focus will be on writing high-quality, maintainable code while preserving the integrity of the prompt messages used in the OpenAI API interactions. 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

Install the necessary dependencies:

npm install express axios

Set up the project structure:

mkdir routes utils data
touch app.js routes/report.js utils/helpers.js

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}`);
});

• 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.

mkdir stock-report-generator
cd stock-report-generator
npm init -y

• 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.

npm install express axios

• 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

mkdir routes utils data
touch app.js routes/report.js utils/helpers.js

• 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

// 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}`);
});

• 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

// 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,
};
</any>

• 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

// 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;
  }
}
</object>

• 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:

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;
  }
}
</string>

• 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:

/**
 * 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);
}
</string>

Sending a Test Request

Use curl or Postman to send a POST request:

mkdir stock-report-generator
cd stock-report-generator
npm init -y

• 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

• Node.js Documentation
• Express.js Documentation
• Axios Documentation
• OpenAI API Reference

---

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

The above is the detailed content of Building a High-Quality Stock Report Generator with Node.js, Express, and OpenAI API. For more information, please follow other related articles on the PHP Chinese website!