Building a Real-Time Financial Market Analyst API with LLMs

Carter Harrison — Tue, 03 Dec 2024 22:39:48 +0000

Financial market data presents unique challenges for developers: it's real-time, constantly changing, and requires careful interpretation. This tutorial walks through building a REST API that combines live financial data with language models to create an intelligent market analysis service. We'll focus on creating a clean, maintainable architecture that can scale with your needs.

Architecture Overview

Before diving into the code, let's understand the key components of our system:

Market Data Service: Handles all interactions with real-time financial data sources. This service abstracts away the complexity of fetching and formatting market data, providing a clean interface for the rest of our application.
Assistant Service: Manages the language model interactions. It takes market data and user queries, then generates intelligent analysis based on current information. By separating this into its own service, we can easily swap out different language models or modify the prompting strategy.
API Routes: Provides RESTful endpoints that combine the above services to handle user requests. The routes handle input validation, error handling, and response formatting.

Project Setup

First, let's set up our project structure. We'll use a modular approach that separates concerns and makes the code easier to test and maintain:

mkdir market-assistant-api
cd market-assistant-api
npm init -y
npm install express openai dotenv axios

You will need to get both an OpenAI API Key and a Pine API Key. With these, make sure to put them in the .env file.

PINE_API_KEY=your_pine_api_key
OPENAI_API_KEY=your_openai_api_key
PORT=3000

Now we can create this directory structure:

market-assistant-api/
├── src/
│   ├── services/
│   │   ├── marketData.js
│   │   └── assistant.js
│   └── server.js
├── .env
└── package.json

This structure separates our code into logical components, making it easier to maintain and test. The services directory contains our core business logic, while routes handles HTTP-specific concerns.

Implementation Details

Market Data Service (marketData.js)

This service encapsulates all market data operations. Each method is focused on a specific type of data retrieval:

getStockPrice: Fetches current price and movement data for a single stock
getMarketTrends: Retrieves sector-wide trend information
getComparisonData: Gathers comparative data for multiple symbols

import axios from "axios";

class MarketDataService {
  constructor(apiKey) {
    this.client = axios.create({
      baseURL: "https://api.pine.dev",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
    });
  }

  async makeQuery(query) {
    const response = await this.client.post("/context", { query });
    return response.data.markdown;
  }

  async getStockPrice(symbol) {
    const query = `current price and daily movement for ${symbol} stock`;
    const data = await this.makeQuery(query);
    return data;
  }

  async getMarketTrends(sector) {
    const query = `current market trends and performance for the ${sector} sector`;
    const data = await this.makeQuery(query);
    return data;
  }

  async getComparisonData(symbols) {
    const symbolList = symbols.join(", ");
    const query = `trends for each stock: ${symbolList}`;
    const data = await this.makeQuery(query);
    return data;
  }
}

export default MarketDataService;

Assistant Service (assistant.js)

The Assistant Service handles the intelligence layer of our API. It takes market data and user queries and generates meaningful analysis:

import { OpenAI } from "openai";

class AssistantService {
  constructor(apiKey) {
    this.client = new OpenAI(apiKey);
  }

  async analyzeQuery(query, marketData) {
    const systemPrompt = `
          You are a financial analysis API. Analyze the following market data and answer the query.
          Only use the provided market data for your analysis. If you can't answer something from
          the provided data, say so explicitly.

          Current Market Data:
          ${marketData}
    `;

    const completion = await this.client.chat.completions.create({
      model: "gpt-4",
      messages: [
        { role: "system", content: systemPrompt },
        { role: "user", content: query },
      ],
      temperature: 0.3,
      max_tokens: 2048,
    });

    return completion.choices[0].message.content;
  }
}

export default AssistantService;

API Routes (server.js)

The API routes tie everything together, providing clean endpoints for clients to interact with:

import express from "express";
import dotenv from "dotenv";
import MarketDataService from "./services/marketData.js";
import AssistantService from "./services/assistant.js";

dotenv.config();

const router = express.Router();
const marketData = new MarketDataService(process.env.PINE_API_KEY);
const assistant = new AssistantService(process.env.OPENAI_API_KEY);

// Get analysis for a single stock
router.get("/analyze/stock/:symbol", async (req, res) => {
  const { symbol } = req.params;
  const { query } = req.query;

  const data = await marketData.getStockPrice(symbol);
  const analysis = await assistant.analyzeQuery(query, data);

  res.json({
    symbol,
    analysis,
    timestamp: new Date().toISOString(),
  });
});

// Get sector analysis
router.get("/analyze/sector/:sector", async (req, res) => {
  const { sector } = req.params;
  const { query } = req.query;

  const data = await marketData.getMarketTrends(sector);
  const analysis = await assistant.analyzeQuery(query, data);

  res.json({
    sector,
    analysis,
    timestamp: new Date().toISOString(),
  });
});

// Compare multiple stocks
router.post("/analyze/compare", async (req, res) => {
  const { symbols, query } = req.body;

  if (!Array.isArray(symbols) || symbols.length < 2) {
    return res.status(400).json({
      error: "Please provide at least two symbols to compare",
    });
  }

  const data = await marketData.getComparisonData(symbols);
  const analysis = await assistant.analyzeQuery(query, data);

  res.json({
    symbols,
    analysis,
    timestamp: new Date().toISOString(),
  });
});

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());
app.use("/api", router);

app.listen(port, () => {
  console.log(`Server is running on port http://localhost:${port}`);
});

API Usage

First, we must start the server

node ./src/server.js

Now, let's look at some practical examples of using it:

Analyzing a Single Stock

Request:

curl "http://localhost:3000/api/analyze/stock/AAPL?query=How%20has%20the%20stock%20performed%20today"

Response:

{
  "symbol": "AAPL",
  "analysis": "Based on the provided market data, Apple Inc. (AAPL) closed at $242.65, which is an increase of $3.06 or 1.28% from the previous close of $239.59. After hours, the stock price slightly increased by $0.10 or 0.04% to $242.75. The day's trading range was between $238.90 and $242.76.",
  "timestamp": "2024-12-03T22:28:13.998Z"
}

Sector Analysis

Request:

curl "http://localhost:3000/api/analyze/sector/technology?query=What%20are%20the%20current%20sector%20trends"

Response:

{
  "sector": "technology",
  "analysis": "Based on the provided market data, the current sector trends in the technology industry for 2024 include:\n\n1. **Generative AI (Gen AI)**: This trend has seen significant growth...",
  "timestamp": "2024-12-03T22:29:09.848Z"
}

Stock Comparison

Request:

curl -X POST "http://localhost:3000/api/analyze/compare" \
     -H "Content-Type: application/json" \
     -d '{
           "symbols": ["AAPL", "MSFT", "GOOGL"],
           "query": "Compare their performance today"
         }'

Response:

{
  "symbols": ["AAPL", "MSFT", "GOOGL"],
  "analysis": "Based on the provided market data, here is the performance comparison for today:\n\n1. **Apple Inc. (AAPL)**\n   - Current Price: $242.65\n   - Change: +3.06 (1.28%)\n...",
  "timestamp": "2024-12-03T22:31:31.991Z"
}

Next Steps

If you want to continue building with the API, these may be some good next steps:

Performance

To maintain good performance, consider implementing:

Caching Layer

Cache frequent queries
Store recent market data
Implement cache invalidation strategies

Rate Limiting

Limit requests per client
Implement token bucket algorithm
Add retry mechanisms

Request Optimization

Batch similar requests
Implement request queuing
Add request timeout handling

For Production

Authentication & Authorization

Implement JWT authentication
Add role-based access control
Set up API key management

Advanced Features

Historical data analysis
Technical indicators
Sentiment analysis
Portfolio management

Monitoring & Logging

Add structured logging
Implement performance monitoring
Set up alerting systems

And thats it! Let me know what y'all think and if you have any questions!

68 Small and Large Projects to Make You a Better Developer 🎉

Carter Harrison — Thu, 30 Apr 2020 23:14:12 +0000

1 ) Make a simple HTTP request only using TCP sockets
2 ) Create a website that shows a map of the coronavirus using MapBox and John Hopkins COVID-19 data.
3 ) Make Conway's game of life using javascript
4 ) A web scraper to put hackernews into a json file
5 ) Write a BASIC compiler
6 ) Make a note program using vim and bash
7 ) Use the plaid API to track your own finances
8 ) Write a web crawler to find hundreds of thousands of websites
9 ) Make a census data API
10 ) Create a single reddit clone
11 ) Make a chrome extension to make the text on any website a different color
12 ) Implement email password authentication
13 ) Create a FTP client
14 ) Create a port scanner
15 ) Implement Merge Sort
16 ) Publish a personal website using AWS S3 and AWS Cloudfront
17 ) Make an algorithm for prime factorization
18 ) Make a code portfolio website
19 ) Create a prime number searcher
20 ) Implement MD5
21 ) Headline extractor for news articles
22 ) Make a twitter bot that tweets a stock price
23 ) Implement XOR Decryption
24 ) Make a MySQL to MongoDB migrator
25 ) Write a HTML prettifier
26 ) Make a Minecraft mod
27 ) Make a database backup script
28 ) Covert color picture to black and white one
29 ) Make a password cracker
30 ) Create a cookie clicker type game
31 ) Make a brain f**k interpreter
32 ) CLI chat using unix sockets
33 ) Make a GIF maker
34 ) Implement Binary Search
35 ) Create a YouTube downloader
36 ) Make a Chess bot
37 ) Make a text editor
38 ) Make a Netflix clone
39 ) Create a web server from scratch
40 ) Make your own file explorer
41 ) Make a telegram chat bot
42 ) Make an address book website
43 ) Latitude longitude point to geohash
44 ) Make a color scheme creator website
45 ) Create a ray tracer
46 ) iOS app to advertise a bluetooth signal
47 ) Make a country to IP API
48 ) Create a SQL query optimizer
49 ) Write a blockchain example in less than 100 lines of javascript
50 ) Implement SHA256
51 ) Make a reddit bot
52 ) Implement a hash map
53 ) Create a sound board website
54 ) Write the game snake with only javascript/html/css
55 ) Make a digits of pi calculator website
56 ) Make a tic tak toe website
57 ) Use Dijkstra algorithm to solve a maze
58 ) Make a image resizer
59 ) Create a sudoku solver without looking up an algorithm online
60 ) Make a database from scratch
61 ) Write a JSON parser in Haskell
62 ) Implement Quicksort
63 ) Make the hangman game
64 ) Create a super simple operating system
65 ) Implement ECDSA
66 ) Create a neural network to read numbers from handwriting
67 ) Make a discord bot
68 ) Make a graphing library in javascript

Shameless Plug: My sideproject Vay provides simple APIs powered by open data that are great for side projects.

100DaysOfCoders are getting free plans at Vay

Carter Harrison — Sun, 22 Mar 2020 21:32:48 +0000

Hey 100DaysOfCoders,

My name is Carter Harrison, and I am the founder of Vay — a startup that builds simple APIs on top of open data.

I learned how to code by building, not by taking online courses or by going to college. In my opinion, #100DaysOfCode is the fastest and most effective way to learn development. Because of this, we are giving away free starter plans to support those who are attempting the #100DaysOfCode challenge.

You'll get access to all of our APIs free of attribution, and 50,000 monthly API requests for 6 months.

Click here for more info

Hardest text file to parse 🚨

Carter Harrison — Sun, 22 Mar 2020 21:27:31 +0000

USGS Datasheets are incredibly hard to parse, just look at One. At least they provide a 46 page spec. They are full of edge cases and nuances.

I needed to parse them for my startup Vay, here is my attempt in golang: https://github.com/carterharrison/dsdata. It is open source so feel free to make improvements.

It is a fun challenge, you should give it a try to hone your skills.

Forem: Carter Harrison

Building a Real-Time Financial Market Analyst API with LLMs

Architecture Overview

Project Setup

Implementation Details

Market Data Service (marketData.js)

Assistant Service (assistant.js)

API Routes (server.js)

API Usage

Analyzing a Single Stock

Sector Analysis

Stock Comparison

Next Steps

Performance

For Production

68 Small and Large Projects to Make You a Better Developer 🎉

100DaysOfCoders are getting free plans at Vay

Hardest text file to parse 🚨