Blueprint: private wealth intelligence

A private wealth copilot grounded in your own records.

Use RushDB as the evidence graph and vLLM as the local inference layer so family-office and VC teams can ask portfolio questions against HOLDING, COMPANY, DEAL, INVESTMENT_MEMO, and POLICY records without sending private context to a hosted LLM. The backend retrieves approved memos like the Northstar Compute concentration-risk note and requires the model to cite record IDs such as holding-ai-infra-co or refuse.

On-prem inference for wealth management is a RushDB and vLLM blueprint that grounds portfolio-question answering in PORTFOLIO, HOLDING, COMPANY, DEAL, INVESTMENT_MEMO, and POLICY records, keeping model inference inside the controlled environment and requiring cited evidence or refusal.

Private wealth teams cannot treat a chatbot as an investment system.

Family offices and VC teams work across PORTFOLIO records, cap tables, INVESTMENT_MEMO notes, POLICY documents, and private DEAL flow like a Series B follow-on diligence. A general chat interface can sound confident about AI infrastructure concentration risk while missing the actual evidence, the IC-approval POLICY, or the access boundary that should gate the answer — and a wrong but polished answer about allocation or diligence status can reach a committee before anyone checks the source memo.

Before

  • Portfolio data, memos, and diligence notes live in separate systems
  • Hosted model calls create data-residency and confidentiality questions
  • Answers are hard to audit back to source records
  • Unsupported reasoning can look as polished as grounded analysis

With RushDB

  • RushDB keeps holdings, deals, memos, policies, and citations as connected records
  • vLLM serves the chosen model inside the controlled environment
  • Schema and retrieval constrain prompts to available structure and evidence
  • The backend can refuse unsupported questions instead of inventing answers

Graph intelligence on ingest

Incoming data becomes queryable graph context.

PORTFOLIO payloads nest HOLDING, COMPANY, INVESTMENT_MEMO, POLICY, and DEAL records as they are imported. RushDB types allocation percentages and status fields on arrival and indexes memo and policy text, so retrieval can pull only approved, portfolio-scoped evidence like memo-northstar-q2 before any prompt reaches the local vLLM endpoint.

01

Normalize as data arrives

HOLDING, INVESTMENT_MEMO, and POLICY records are typed on ingest so allocation, status, and text fields are immediately filterable and searchable.

02

Auto-link nested structure

When a PORTFOLIO payload nests HOLDING, COMPANY, and INVESTMENT_MEMO entries, those become relationships automatically instead of a flat memo dump.

03

Enrich scattered sources

Suggested relationship analysis surfaces shared portfolioId and companyId keys across DEAL and POLICY records so evidence retrieval stays scoped to one fund or account.

Suggested relationship analysis requires an LLM configured for the project. Suggestions stay in draft form until you approve them, so inferred domain meaning never mutates the graph silently. You can also add explicit relationships through the SDK or API.

Review suggested relationship patterns

Data model

One flexible graph for the workflow.

Start with the payload shape your product already produces. RushDB stores it as Records, infers typed properties, and keeps nested or approved domain relationships queryable.

Schema sketch
Private portfolio payload

RushDB stores portfolio evidence and policy records; local inference receives only cited backend-selected context.

{
  "portfolioId": "fo-2026",
  "strategy": "growth",
  "HOLDING": [{
    "holdingId": "holding-ai-infra-co",
    "allocationPct": 6.8,
    "COMPANY": { "companyId": "northstar-compute", "sector": "ai_infrastructure" }
  }],
  "DEAL": [{
    "dealId": "series-b-follow-on",
    "stage": "diligence",
    "INVESTMENT_MEMO": [{ "memoId": "memo-northstar-q2", "status": "approved" }]
  }],
  "POLICY": [{ "policyId": "ic-approval", "requiresHumanReview": true }]
}

Working example

Ask a portfolio question. Return cited evidence or refuse.

The backend retrieves holdings and approved investment memos from RushDB, sends only cited evidence to the local vLLM endpoint, and requires record IDs in the response.

Input
PORTFOLIO fo-2026
  HOLDING ai-infra-co allocation: 6.8%
  COMPANY "Northstar Compute"
  INVESTMENT_MEMO "GPU supply concentration remains the primary risk..."
  POLICY "Do not recommend trades without IC approval."
  DEAL "Series B follow-on diligence"
Query
{
  "labels": ["INVESTMENT_MEMO"],
  "propertyName": "text",
  "query": "AI infrastructure exposure, concentration risk, and follow-up diligence",
  "where": {
    "PORTFOLIO": { "portfolioId": "fo-2026" },
    "status": "approved"
  },
  "limit": 8
}
Result
{
  "answerability": "grounded",
  "summary": "AI infrastructure exposure is concentrated in Northstar Compute.",
  "citations": ["holding-ai-infra-co", "memo-northstar-q2", "policy-ic-approval"],
  "unsupportedClaims": [],
  "requiresHumanReview": true
}

TypeScript SDK

Retrieve evidence first. Run local inference second.

RushDB supplies schema, retrieval, relationships, and citations. vLLM runs the model inside the controlled environment. The thin UI only calls this backend workflow and is outside the blueprint scope.

from openai import OpenAI
from rushdb import RushDB

db = RushDB('RUSHDB_API_KEY')
llm = OpenAI(base_url='http://vllm.internal:8000/v1', api_key='local')

schema = db.ai.get_schema_markdown({
    'labels': ['PORTFOLIO', 'HOLDING', 'COMPANY', 'DEAL', 'INVESTMENT_MEMO', 'POLICY'],
}).data

holdings = db.records.find({
    'labels': ['HOLDING'],
    'where': {'PORTFOLIO': {'portfolioId': 'fo-2026'}},
    'limit': 50,
}).data

memos = db.ai.search({
    'labels': ['INVESTMENT_MEMO'],
    'propertyName': 'text',
    'query': 'AI infrastructure exposure, concentration risk, and follow-up diligence',
    'where': {'PORTFOLIO': {'portfolioId': 'fo-2026'}, 'status': 'approved'},
    'limit': 8,
}).data

answer = llm.chat.completions.create(
    model='local-wealth-model',
    messages=[{
        'role': 'user',
        'content': f'Use only this schema and evidence. Cite record IDs. Refuse unsupported claims.\n{schema}\n{holdings}\n{memos}',
    }],
)

Implementation blueprint

Build the on-prem wealth-intelligence path.

Use this sequence to build a private backend for portfolio intelligence without turning the model into the source of truth.

  1. 01Deploy RushDB and vLLM inside the controlled environment
  2. 02Import PORTFOLIO, HOLDING, COMPANY, DEAL, INVESTMENT_MEMO, POLICY, and SOURCE records
  3. 03Create managed or external indexes for memo and policy text
  4. 04Retrieve schema, holdings, policies, and cited memo chunks before inference
  5. 05Send only evidence payloads to vLLM and require citations or refusal
  6. 06Keep the thin UI out of the reasoning path; it only renders backend results

Build path

  • Model portfolio intelligence as records and relationships, not prompt-only memory.
  • Keep local inference behind an evidence-gated backend endpoint.
  • Require answers to cite RushDB record IDs and source documents.
  • Add human-review and investment-policy gates before any recommendation workflow.

How it works

Build the smallest useful workflow first.

01

Keep inference on-prem

Serve the model through vLLM inside the controlled network and send it only the evidence selected by the backend.

02

Build an evidence graph

Store holdings, companies, funds, deal memos, policies, diligence notes, and source documents as connected RushDB records.

03

Gate every answer

Load schema, retrieve cited records, apply access filters, and require the model to cite evidence or refuse unsupported claims.

Know where it fits.

Grounded does not mean guaranteed correct

This pattern reduces unsupported answers by evidence-gating prompts and requiring citations. It does not guarantee financial correctness, investment suitability, or zero hallucinations.

Thin UI stays out of scope

The case focuses on the private backend: RushDB for evidence, vLLM for local inference, and policy gates for review. The UI should remain a thin client over those decisions.

Questions developers ask.