AI Bank Statement Automation
Extract, redact, analyze, and query bank-statement PDFs with local or cloud models.
Per-dimension scores and reasoning
The README describes PDF extraction, PII redaction, vector storage, RAG, optional cloud LLMs, MLflow tracing, and several persistent services, providing a useful high-level data-flow account. Tests independently check masking of email, telephone, and account-number patterns. Deductions apply because the supplied files show no least-privilege policy, pre-action confirmation, retention rules, detailed access controls, external-provider data policy, or rollback/recovery workflow. PII coverage is limited to a few patterns, and the roadmap acknowledges that names and addresses need stronger protection. Many dependencies are pinned, but several remain unpinned or duplicated, with no vulnerability scanning, integrity verification, or security-update evidence. Attribution is limited to the repository identity, technology links, and a geographic statement; the publisher and accountable maintainer remain unclear.
The README, project map, requirements, and tests are reasonably consistent around the Deep Agents path for PDF extraction, redaction, vector storage, and querying, including a deterministic no-LLM workflow. Deductions reflect the absence of the runtime implementations, API tests, and operational handling needed to substantiate the broader full-stack and multi-framework claims. Production backend, Docker, and Kubernetes capabilities also appear both as present features and roadmap items. Dependency resolution is weakened by a mixture of exact pins, ranges, and unconstrained packages, plus a duplicate instructor declaration. Visible failure guidance consists mainly of assertion messages and documentation pointers; there is little evidence of user-facing structured errors, retries, or graceful degradation.
The material identifies personal-finance, deterministic offline, local-LLM, cloud-model, notebook, API, frontend, and sandboxed-agent scenarios. It also distinguishes model-size, context, JSON-output, GPU, and harness constraints. Deductions apply because the harnesses are explicitly experimental and their skill copies do not synchronize automatically; local-model quality and strict JSON generation are known limitations. The skill test proves only that five files have names and descriptions, while their actual trigger language and dispatch implementation are absent, so overlap and false-trigger controls cannot be established. Environment guidance is substantial but assumes a heavy service stack, and cross-platform coverage beyond a brief Windows virtual-environment note is incomplete.
The README has strong organization across features, architecture, project structure, quick starts, configuration, developer notes, roadmap, and licensing, earning full credit for information architecture. Installation paths and examples cover CrewAI, Deep Agents, and the Docker stack, but referenced guides and implementations were not supplied, so their completeness cannot be confirmed. Naming is generally stable, although three harnesses and unsynchronized skill copies create drift risk. The source explicitly records model, context, JSON, PII, and experimental limitations. A complete Apache-2.0 license is present. No release versioning, changelog, or migration history is shown. Maintenance responsibility is only weakly implied by the repository owner and general upgrade notes, without named maintainers, support policy, or update commitments.
The candidate defines useful outputs including Markdown reports, structured extraction, RAG answers, an API, and a frontend, and supplies a short no-LLM workflow. Combining layout detection, OCR, redaction, retrieval, and financial analysis offers plausible value over manual processing. Deductions reflect the lack of representative outputs, quality measurements, or enough implementation evidence to validate the broader utility claims, while the README warns that local models may fail strict JSON. The full deployment may require Python and ML dependencies, several stateful services, Docker, recent NVIDIA tooling, and large models. Apart from a broad GPU build-time statement, no resource benchmarks or cost comparison substantiate cost-benefit claims.
The tests trace a limited set of claims to inspectable checks: skill metadata, PDF text extraction, masking of common PII patterns, and a vector-store query round trip. These checks broadly corroborate the README and dependency list. Deductions apply because most full-stack, security, performance, and multi-harness claims appear only in the README, without the relevant implementations, CI evidence, test results, benchmarks, or output fixtures. The PDF test substitutes a synthetic document when the sample is unavailable, so it does not establish performance on the advertised repository sample. Promotional claims, implemented capabilities, and future plans are not always distinctly separated, notably where production backend and deployment features also appear on the roadmap.
- Bank statements contain highly sensitive financial and identity data. Before using real files, verify every LLM, tracing, vector-store, and logging path and ensure data cannot reach an unapproved external service.
- The supplied PII evidence covers only email, telephone, and account-number patterns; names, addresses, transaction narratives, and identifying combinations may still enter embeddings, logs, or traces.
- The full deployment creates databases, vector indexes, uploads, and tracing records, but the material supplies no deletion, rollback, backup-recovery, or retention procedure.
- The requirements include unconstrained, ranged, duplicated, and exactly pinned entries. Lock the complete dependency graph, scan it for vulnerabilities, and review container images before processing real financial data.
- Do not treat generated financial analysis as validated accounting, credit, or investment advice; the supplied evidence does not establish output accuracy or decision-risk controls.
What does this agent do, and when should you use it?
This repository is a bank-statement document-processing and personal-finance analysis system. It combines PyMuPDF, YOLO, OCR, and LLM-based table extraction, then redacts PII before storing embeddings in Qdrant or Chroma. Three experimental harnesses implement the workflow: a CrewAI notebook baseline, LangChain Deep Agents, and Hermes in a Docker sandbox; Deep Agents also includes a deterministic mode that does not require an LLM. A full-stack layer exposes REST authentication, document processing, and agent runs through FastAPI, PostgreSQL, Celery, Redis, and a React SPA. LiteLLM connects the application to LM Studio, Ollama, OpenAI, DeepSeek, and other providers, while MLflow tracing is available on the CrewAI path. It is best suited to technical teams prepared to self-host and validate a financial-document pipeline, rather than users seeking a managed personal-finance service.
The pipeline reads bank-statement PDFs and uses PyMuPDF, YOLO layout detection, and OCR to recover document content, followed by LLM-based table extraction and structuring. Its skills cover bank-statement-parsing, pii-handling, financial-analysis, rag-query-handling, and output-format; PII is redacted before embeddings are written to Qdrant or Chroma. The resulting data supports income and expense categorization, trend analysis, and natural-language questions. CrewAI runs through a Jupyter notebook, Deep Agents exposes run_e2e.py and a deterministic pipeline mode, and Hermes runs through its CLI in Docker only. The full-stack deployment adds authenticated FastAPI endpoints for LLMs, documents, and agent_runs, delegates background work to Celery, persists application data in PostgreSQL, and presents results through a React SPA.
- A personal-finance application developer needs to turn bank-statement PDFs into structured, searchable transaction data.
- A team handling sensitive financial documents wants PII removed before any content is embedded in a vector database.
- An agent engineer wants to compare CrewAI, Deep Agents, and Hermes against the same bank-statement workflow.
- A privacy-conscious organization wants to analyze statements with LM Studio or Ollama instead of depending exclusively on a cloud model.
- A backend team needs an asynchronous document-processing service built around FastAPI, Celery, PostgreSQL, and Qdrant.
- A researcher wants to experiment with CrewAI in Jupyter and inspect LLM and task traces through MLflow.
What are this agent's strengths and limitations?
- It covers an end-to-end statement workflow: YOLO/OCR extraction, LLM structuring, PII redaction, vector retrieval, and financial analysis.
- The same domain workflow is available through CrewAI, Deep Agents, and Hermes, with a deterministic no-LLM test and E2E path.
- LiteLLM supports local LM Studio and Ollama deployments as well as multiple cloud providers, and the implementation accounts for models that return reasoning_content.
- The repository includes a FastAPI API, Celery workers, PostgreSQL, Qdrant, a React frontend, Docker Compose, and Kubernetes manifests rather than only a research notebook.
- PII redaction occurs before vector-database embedding, providing a clearly documented privacy boundary.
- The three harnesses are explicitly experimental and maintain separate skill copies without automatic synchronization, creating drift and maintenance risk.
- Recommended local deployments need a model of at least about 9B parameters and a 16K or preferably 32K context window, which raises memory and compute requirements.
- Local models are documented as unreliable at strict JSON generation, so adopters may need Markdown output, a second model call, instructor, or custom post-processing.
- The full deployment introduces PostgreSQL, Redis, Qdrant, Celery, frontend, backend, and secret-management responsibilities.
- Stronger PII detection for names and addresses, production embeddings for Deep Agents, and shared skill synchronization remain roadmap items.
- GPU deployments depend on the NVIDIA container stack and compatible drivers, while the Hermes harness is restricted to Docker execution.
How do you install or deploy this agent?
For the CrewAI environment:
git clone https://github.com/johnsonhk88/AI-Bank-Statement-Document-Automation-By-LLM-And-Personal-Finanical-Analysis-Prediction.git
cd AI-Bank-Statement-Document-Automation-By-LLM-And-Personal-Finanical-Analysis-Prediction
python -m venv venv
source venv/bin/activate
pip install -r requirements.txtLoad a recommended 9B-or-larger model in LM Studio, configure at least a 16K context window, and start its local server at http://localhost:1234. The supplied LiteLLM example uses base_url="http://localhost:1234/v1" and api_key="lm-studio".
The full application requires Docker 24+ with BuildKit and Docker Compose v2+. Configure it with:
cp infra/.env.example infra/.env
python -c "import secrets; print(secrets.token_urlsafe(32))"
python -c "import bcrypt; print(bcrypt.hashpw(b'your-password', bcrypt.gensalt()).decode())"Place those values in JWT_SECRET and ADMIN_PASSWORD_HASH in infra/.env. Escape every $ in the bcrypt hash as $$ for Docker Compose. Then run:
cd infra && DOCKER_BUILDKIT=1 docker compose --profile prod up -d --buildGPU acceleration is optional; using it inside containers additionally requires the NVIDIA Container Toolkit and a compatible driver.
How do you use this agent?
For the CrewAI path, start the main notebook:
jupyter notebook backend/app/core/ai_agent_skills_dev.ipynbFor a testable path that does not call an LLM:
cd agents/deep-agents
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
PYTHONPATH=. pytest tests/ -v
PYTHONPATH=. python run_e2e.py --pdf ../../data/bank-statement-document/Dummy-Bank-Statement.pdf --question "What amounts appear in the statement?" --mode pipelineAfter starting the production Compose profile, open http://localhost. For frontend development, run docker compose up -d from infra, then npm install && npm run dev from web and open http://localhost:5173. Direct asynchronous model calls can use litellm.acompletion with model, base_url, api_key, and messages; credentials for cloud-hosted models depend on the selected provider.
How does this agent compare with similar options?
CrewAI is the notebook-oriented baseline and has MLflow tracing support. Deep Agents provides a local virtual-environment workflow, tests, run_e2e.py, and a deterministic pipeline that can run without an LLM. Hermes is launched through its CLI and is restricted to a Docker sandbox. All three target the same statement-processing task, but their skill copies are independent and do not synchronize automatically. For model execution, LM Studio and Ollama provide local options, while LiteLLM can also route to services such as OpenAI and DeepSeek; local models reduce provider dependence but carry documented model-size, context-window, and JSON-output constraints.