FinGPT: financial large language models you fine-tune yourself
FinGPT: Open-Source Financial Large Language Models! Revolutionize 🔥 We release the trained model on HuggingFace.
At a glance
- What is it?
- FinGPT is an MIT-licensed research project from the AI4Finance Foundation that packages instruction-tuning, LoRA fine-tuning and a forecaster demo for financial LLMs. It is a codebase to adapt, not a service to log into.
- Who is it for?
- Adopt FinGPT if you have GPU capacity and want to own the fine-tuning loop for sentiment or forecasting tasks, because the repository ships the LoRA notebooks, the benchmark code and the training scripts rather than a hosted endpoint. Skip it if you need a supported product with an SLA, a login, or an API key: the README documents none of those, and the PyPI package is a thin 0.0.1 wrapper around requirements.txt.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 16 days ago.
- What is it written in?
- Mainly Jupyter Notebook, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 17, 2026, and from our analysis. They are not legal advice.
Editorial analysis
The problem FinGPT solves: retraining finance models without a Bloomberg budget
The README states the argument plainly: BloombergGPT trained on a mixture of finance and general data, took about 53 days and cost around $3M. FinGPT's premise is that retraining at that scale is not something a small team can repeat monthly, so the project focuses on lightweight adaptation instead. The README puts the cost of a single fine-tuning run at less than $300.
That framing determines who the project is for. It is aimed at researchers and engineers who already have a base open-source LLM and want to push financial behaviour into it with LoRA adapters, not at analysts who want to type a ticker into a box. The repository reflects that: the top level is dominated by Jupyter notebooks such as FinGPT_Training_LoRA_with_ChatGLM2_6B_for_Beginners.ipynb and FinGPT_ Training with LoRA and Meta-Llama-3-8B.ipynb, plus a fingpt/ package tree and a tests/ directory. The README also makes a point about data access: BloombergGPT has privileged data and APIs, while FinGPT leans on open data and an automatic curation pipeline.
The third claim in the README is RLHF, described as the missing piece in BloombergGPT and as the mechanism that would let a model learn individual risk-aversion levels or investing habits. Treat that as a research direction rather than a shipped feature. The README describes it as a key technology; it does not point to a finished RLHF pipeline in the repository the way it points to the Forecaster demo.
How FinGPT is put together: notebooks, a thin package and HuggingFace weights
The architecture visible in the repository is layered rather than monolithic. At the bottom sit base models pulled through transformers, with peft supplying LoRA adapters and bitsandbytes listed in requirements.txt for quantised GPU work. Above that, the fingpt/ directory holds task-specific code, including FinGPT_Forecaster and FinGPT_Benchmark, and the trained artefacts live on HuggingFace under the FinGPT organisation rather than in the repository.
The data flow for the forecaster is documented as a dataset, FinGPT/fingpt-forecaster-dow30-202305-202405, paired with a LoRA checkpoint, fingpt-forecaster_dow30_llama2-7b_lora. A user supplies a ticker symbol and a start date, and the model produces a forecast. The released sentiment model, fingpt-sentiment_llama2-13b_lora, follows the same pattern: a general base model plus a small adapter, which is what keeps the retraining cost low enough to repeat.
The packaging layer is deliberately minimal. setup.py declares version 0.0.1, name FinGPT, and reads requirements.txt to build install_requires. So the pip package is essentially a dependency manifest plus find_packages() over the repository tree. If you expect a stable Python API surface with semantic versioning, this is not it. The real interface is the notebooks and the HuggingFace model IDs.
Installing FinGPT and running a first LoRA fine-tuning job
The README gives a two-step install: clone the repository, then install both the requirements file and the package itself in editable mode. The editable install matters because the notebooks import from the local fingpt/ tree, not from a published wheel.
git clone https://github.com/AI4Finance-Foundation/FinGPT.git
cd FinGPT
pip install -r requirements.txt
pip install -e .After this you should have transformers, peft, accelerate, datasets, torch and bitsandbytes in the environment. Note the two pins that requirements.txt carries with comments: numpy<2 because of NumPy 2.x compatibility issues with PyTorch, and bitsandbytes>=0.43.1 for GPU acceleration. The file also states that Triton is installed separately for supported NVIDIA GPU environments, so do not expect pip to pull it in.
For a first run without a GPU, the README shows a cloud provider path. It sets an environment variable rather than importing a client library, which suggests the provider switch is read somewhere in the codebase at runtime.
import os
os.environ['FINGPT_LLM_PROVIDER'] = 'openai'The README does not document which providers beyond openai are accepted, nor what credentials the code expects once that variable is set. Check the source before relying on it.
If you want to see output before touching training, the README points to a hosted HuggingFace Space for FinGPT-Forecaster where you enter a ticker such as AAPL, MSFT or NVDA and a start date. That is the fastest way to judge whether the model's forecasts are worth the setup cost. For local work, the beginner notebooks are the entry point: FinGPT_Training_LoRA_with_ChatGLM2_6B_for_Beginners.ipynb and the Meta-Llama-3-8B training notebook. The README does not state the VRAM needed for either, so check SETUP.md, which it describes as covering hardware requirements and troubleshooting.
Where FinGPT breaks down: version pinning, packaging and scope
The most concrete constraint is Python. setup.py sets python_requires to >=3.8,<3.13 with an inline comment that Python 3.12 may have compatibility issues with ML dependencies, yet the classifiers list 3.8 through 3.12. That is an internal contradiction in the repository: the classifiers advertise 3.12, the constraint excludes it, and the comment explains why. Plan for 3.10 or 3.11 and read the constraint, not the badge. The README's own Python badge is also inconsistent, pointing at a 3.6 release page while the setup metadata says 3.8 minimum.
The second limitation is that FinGPT is a research codebase wearing a package name. Version 0.0.1, no documented API stability, no changelog beyond a v1.0.0 release entry, and no rollback procedure described anywhere in the README. If your deployment needs predictable upgrades, you are maintaining that discipline yourself.
The third is domain scope. The released artefacts the README names are a sentiment model and a forecaster trained on Dow 30 data from 2023-05 to 2024-05. A Dow 30 forecaster is not a general market model, and the README does not claim otherwise. If your universe is small caps, fixed income or non-US equities, the released checkpoint gives you no evidence of coverage. This is the wrong tool when you need a validated, auditable signal: the README describes research releases and demos, and nothing about backtesting guarantees, regulatory review or model risk documentation.
FinGPT against FinBERT and BloombergGPT: different jobs, not better and worse
The comparison people reach for is FinGPT versus FinBERT, and the difference is architectural rather than a matter of quality. FinBERT is a BERT-family encoder fine-tuned for classification; you get a label and a probability. FinGPT is built on decoder LLMs such as Llama 2 and ChatGLM2 and produces generated text, which is why the Forecaster can emit a narrative forecast from a ticker and a date instead of a sentiment score. If your pipeline needs a sentiment label per headline at high throughput, an encoder classifier is the smaller, cheaper component. If you need generated commentary or instruction-following across tasks, the decoder route is the one that fits.
The BloombergGPT comparison is the one the README makes itself, and it is a comparison of economics rather than architecture. BloombergGPT trained from scratch on a finance and general data mixture over roughly 53 days at around $3M. FinGPT adapts an existing open base model with LoRA, which the README prices at under $300 per fine-tuning run. The trade is control and reproducibility against capability: you are dependent on whatever base model you choose, and your ceiling is that model's ceiling plus your adapter. BloombergGPT's advantage is privileged data, which FinGPT cannot replicate and does not pretend to. Between FinGPT and a general assistant like ChatGPT, the distinction is ownership of the weights and the training loop; FinGPT's README positions the project around being able to update a model weekly or monthly on your own data.
Licence, upgrade cost and what the repository actually commits to
FinGPT is MIT licensed, both in the LICENSE file and in the setup.py classifier, which is the permissive end of the spectrum: you can use it commercially, modify it and redistribute it, provided the copyright notice and permission notice travel with it. That covers the repository code. It does not automatically cover the HuggingFace checkpoints, which are separate artefacts with their own terms, and it does not cover the base models you fine-tune, which carry their own licences. If you plan to ship a product built on a Llama 2 or ChatGLM2 adapter, the base model licence is the one to read, not FinGPT's. None of this is legal advice; check the terms of each artefact you download.
Upgrade cost is where the thin packaging shows. Because install_requires is generated from requirements.txt at install time, the dependency set is whatever the file said when you cloned. There is no lockfile in the repository listing. ML dependency trees move, and the numpy<2 and bitsandbytes>=0.43.1 pins exist precisely because they broke before. Reproducing a training run six months later means pinning the whole tree yourself, including torch, which requirements.txt leaves unpinned.
The maintenance signal is straightforward: the repository is not archived, and the last push was on 2026-09-08. The most recent release listed is v1.0.0 from 2026-04-08, described as an open-source financial AI platform. The README's What's New section, by contrast, stops at November 2023 with the Forecaster release. Those two things tell you the code moves more often than the front-page narrative does.
Editorial conclusion
Adopt FinGPT if you have GPU capacity and want to own the fine-tuning loop for sentiment or forecasting tasks, because the repository ships the LoRA notebooks, the benchmark code and the training scripts rather than a hosted endpoint. Skip it if you need a supported product with an SLA, a login, or an API key: the README documents none of those, and the PyPI package is a thin 0.0.1 wrapper around requirements.txt. Before committing, verify which Python version your environment pins, since setup.py declares python_requires >=3.8,<3.13 and requirements.txt holds numpy<2 for PyTorch compatibility, then confirm the specific HuggingFace checkpoint you intend to load still matches the notebook you plan to run.
Frequently asked questions
What is FinGPT?
FinGPT is an open-source financial large language model project from the AI4Finance Foundation. The repository contains LoRA fine-tuning notebooks, a forecaster, a benchmark, and links to trained models published on HuggingFace under the FinGPT organisation.
How do I install FinGPT?
The README clones the repository, then runs pip install -r requirements.txt followed by pip install -e . from inside the cloned directory. setup.py declares python_requires >=3.8,<3.13, so avoid Python 3.12 for the ML dependencies.
How do I use FinGPT?
The README offers three routes: the hosted HuggingFace Space for FinGPT-Forecaster, a cloud provider path that sets the FINGPT_LLM_PROVIDER environment variable, and local training through the LoRA notebooks such as FinGPT_Training_LoRA_with_ChatGLM2_6B_for_Beginners.ipynb. SETUP.md is the reference for hardware requirements.
Is FinGPT open source?
Yes. The repository is MIT licensed, stated in the LICENSE file and in the setup.py classifier. The HuggingFace checkpoints and any base model you fine-tune are separate artefacts with their own terms.
Is FinGPT free?
The code is MIT licensed, so there is no licence fee. The README frames cost in terms of compute: it states that a fine-tuning run costs less than $300, in contrast to the roughly $3M and 53 days it attributes to BloombergGPT.
How does FinGPT compare with BloombergGPT?
The README presents it as an economics comparison. BloombergGPT trained from scratch on finance and general data over about 53 days at around $3M, while FinGPT adapts existing open base models with LoRA at under $300 per fine-tuning run. FinGPT does not have BloombergGPT's privileged data access.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ai4finance-foundation-fingpt)