viaNexus Agentic Service Technology
vAST is the agent-ready access layer for viaNexus financial data. It connects MCP clients, Financial Chat Agent, and SDK workflows to 30+ institutional datasets through one signed credential, with server-side dataset permissions built in.
one platform · every dataset · any agent
Works with leading LLM providers
About
Financial agents need more than an API key. They need licensed data, normalized rows, and permissions that hold up across every tool call.
The problem
Vendor sprawl
Thirty vendor contracts.
News, fundamentals, transcripts, market data, reference data. Every provider has a different API, a different auth, a different invoice. Your agent has to talk to all of them.
Entitlements
Entitlements at the row level.
User A pays for European market data, user B doesn’t. Same agent, same query, different rows allowed. If the agent sees data the user can’t use, you’re in violation.
Machine auth
Auth that LLMs understand.
API keys leak, hardcoded tokens expire, OAuth-for-humans doesn’t fit machines. Agents need credentials they can present, refresh, and scope without a human in the loop.
Financial data is fragmented across providers, subscriptions, and auth models. Before an agent can answer safely, it has to know which data exists, which rows a user is allowed to see, and which credential it can present.
What vAST changes
viaNexus provides the financial data: bundled NexusCore datasets, premium NexusEdge partner data, and provider access behind one account. vAST is the agent access layer on top, so every client uses the same catalog, auth, and dataset permissions.
Data provider
Normalized market data, fundamentals, news, transcripts, reference data, and partner datasets.
Permissions
Software statements and tokens enforce which datasets each agent or user can reach.
Interfaces
MCP, Financial Chat Agent, and SDK all reach the same allowed data through different calling styles.
Access
Pick the surface closest to where your agent runs. MCP, Financial Chat Agent, and SDK share the same auth, catalog, and dataset permissions.
Protocol
Use MCP if your agent already lives in Claude, Cursor, ChatGPT, or another MCP client.
MCP quickstart →Product
Use Financial Chat Agent if you want hosted chat with a pk_... token.
Library
Use SDK if you want to own the agent loop, memory, prompts, model, and infra.
SDK quickstart →MCP service
Drop the endpoint into Claude, Cursor, ChatGPT, or your own app. The agent gets search and fetch wired to your subscribed datasets.
There are two MCP endpoints, depending on what data you need. Both authenticate against the same viaNexus account.
Choose your tutorial
https://vast.blueskyapi.com/vianexus/mcp
https://vast.blueskyapi.com/mtnewswires/mcp
Open Claude → Customize → Connectors → click + → Add custom connector. Paste the viaNexus endpoint and click Add.
Endpoint
https://vast.blueskyapi.com/vianexus/mcp
Find viaNexus MCP in the Not connected list and click Connect. The OAuth popup opens. Sign in with your viaNexus email + password.
That’s it. You’re done.
Signed in successfully? You’re connected. Skip ahead to step 05 to start asking.
Need ideas? Try a pre-built Claude skill or watch a demo.
No account yet? Click Sign up, then continue to step 03.
Hitting issues? Reach out to us.
Click Sign up on the OAuth popup. Fill in your details and click Create your account.
After creating your account, the OAuth popup hands off to a subscriptions page. Start the free trial or pick the plan and datasets you want for this connector. Existing users with an active subscription can skip this step; otherwise add datasets in the console.
New chat → + → Connectors → toggle viaNexus MCP on. Claude now has access to whatever your subscription includes, nothing more, nothing less.
Want more datasets? Browse the full catalog and add subscriptions in your viaNexus console or jump to the catalog section.
In Claude: Customize → Connectors → Browse connectors. Search for MT Newswires and add it.
Adding the connector in step 01 takes you straight to the OAuth popup, no extra Connect click. Sign in with your viaNexus email + password.
Signed in successfully? You’re connected. Skip ahead to step 05 to ask for the news.
Need ideas? Try a pre-built Claude skill or watch a demo.
No account yet? Click Sign up, then continue to step 03.
Fill in your details and click Create your account. Skip this step if you signed in with an existing viaNexus account.
Choose a viaNexus plan or continue on the free trial. Skip this step if you signed in and already have an active subscription.
New chat → + → Connectors → toggle MT Newswires on. Real-time North America & Global headlines, in-line.
Want more than news? Add datasets in your viaNexus console, or use the universal viaNexus connector for the full catalog.
Other clients
Coming Soon
One-click install for the viaNexus connector, bring-your-own API key.
Notify me →Coming Soon
Same endpoint, same datasets. MCP support for the OpenAI platform is in active development.
Notify me →Any MCP client
Anything that speaks MCP. Paste the viaNexus endpoint and handle OAuth via your client’s connector config.
Read the docs →Security
One signed credential starts the OAuth flow. Every access method uses the same token introspection and dataset-permission checks: MCP, Chat Agent, SDK.
The flow
YOUR AGENT
Signed JWT
VIANEXUS AUTH
Identity verified
MCP SERVER
Permission checks
01 / 05
A signed JWT issued from your viaNexus account. It identifies the OAuth client and can carry dataset permission patterns such as EDGE:MT_NEWSWIRES*.
In the hosted sign-in flow, the console creates this for you after login. In the SDK flow, you can request one with your API token and pass it to the MCP auth server during registration.
Endpoint
POST https://api.blueskyapi.com/v1/agents/register?token=$VIANEXUS_API_TOKEN
Content-Type: application/json
{
"expiresIn": "1h",
"permissions": {
"include": ["EDGE:MT_NEWSWIRES*"],
"exclude": ["CORE:*"]
}
}
What’s in the JWT
Contact, software ID, payload ID, optional dataset permission patterns, issued-at, expiry. The API token is stored server-side for the exchange; it is not embedded in the JWT.
Standard OAuth 2.0 authorization code flow with PKCE. Dynamic client registration per RFC 7591 lets the client provide its software statement during registration, then continue through the normal authorize and token exchange.
Why PKCE
Protects the token exchange from interception even if the agent runs on a public client, browser, end-user device, or multi-tenant edge function.
OAuth shape
POST /register
{ "software_statement": "$VIANEXUS_JWT", ... }
GET /authorize?response_type=code
&code_challenge=$PKCE_CHALLENGE
POST /token
grant_type=authorization_code
&code=$AUTH_CODE
&code_verifier=$PKCE_VERIFIER
RFC 7591
Dynamic client registration, no pre-registration step.
RFC 7636
PKCE binds the request to a one-time verifier.
Short-lived. The MCP auth server stores the API-service token and dataset permission patterns with the OAuth token, then exposes them through token introspection.
When permissions are present, the MCP service filters dataset discovery and dataset fetches server-side before anything reaches the agent.
Subscription change == zero redeploy
The client can keep the same code. To change dataset access, issue a new software statement or update the subscription/permissions behind the token flow.
Token introspection payload
{
"active": true,
"client_id": "client_...",
"scope": "user",
"aud": "https://vast.blueskyapi.com/vianexus/mcp",
"api_service_token": "pk_...",
"contact": "analyst@example.com",
"dataset_permissions": {
"include": ["EDGE:MT_NEWSWIRES*"]
},
"exp": 1746615262 // 1h TTL
}
MCP request, SDK call, or Financial Chat Agent invocation, all three rely on the same token introspection path. The data plane authenticates the token, reads dataset permissions, and only exposes matching datasets.
Server-side enforcement
The agent never sees a row it doesn’t have rights to. There is no client-side filter to bypass.
Allowed call
POST /mcp/tools/search
Authorization: Bearer $ACCESS_TOKEN
{ "product": "EDGE", "dataset_name": "MT_NEWSWIRES", "symbols": "AAPL" }
200 OK → matching news rows
Out-of-scope call (refused server-side)
POST /mcp/tools/fetch
Authorization: Bearer $ACCESS_TOKEN
{ "product": "CORE", "dataset_name": "REPORTED_FINANCIALS", ... }
error → "Permission denied for dataset CORE:REPORTED_FINANCIALS"
Access tokens expire after 1 hour. Refresh tokens last longer, and SDK clients handle refresh behind the scenes when the OAuth flow has issued one.
Software statements are signed, time-limited handoff artifacts. Rotate or reissue them when you want a new permission set.
Lifecycle
Rotate permissions
POST /v1/agents/register?token=$VIANEXUS_API_TOKEN
Issue a new statement with a tighter permissions object, then reconnect the client with that statement.
Direct consequences of the auth model. Every access method inherits all three.
Credentials
The agent only ever holds a signed statement and a short-lived token. No API keys to leak, no rotating-secrets runbook.
Permissions
Dataset permissions are enforced server-side by the MCP service. Change the permissions behind the statement or subscription, reconnect or refresh the client, and the agent code does not need to change.
Scope
One statement per agent deployment. A news-only agent gets a news-only catalog. The agent never sees what its dataset permissions do not allow.
Financial Chat Agent
Pre-built conversational agent. Powers AskNexus today. Use it with a viaNexus pk_... token, embed it in your app, or add it manually to an OpenBB workspace.
A token and one endpoint. First call lands in 20-35 seconds, follow-ups in about five.
Get token
Create a personal API token in the console. Tokens are prefixed pk_... and are passed as ?token=.
Call /chat
TOKEN="your-vianexus-token"
BASE="https://financial-chat-agent-857389207619.us-central1.run.app"
curl -X POST "$BASE/chat?token=$TOKEN" \
-H "Content-Type: application/json" \
-d '{"message": "What is AAPL trading at right now?"}'
01 / 03
Get a personal API token at console.blueskyapi.com. It starts with pk_.
Use the token as a query param on each hosted agent request.
Environment
export VIANEXUS_TOKEN="pk_..."
Token boundary
The agent can only answer from datasets your token can access.
POST a message to /chat. The response includes an answer and a session_id.
Keep the session id if you want follow-up questions to share context.
Request
BASE="https://financial-chat-agent-857389207619.us-central1.run.app"
curl -X POST "$BASE/chat?token=$VIANEXUS_TOKEN" \
-H "Content-Type: application/json" \
-d '{"message": "What is AAPL trading at right now?"}'
Pass the session_id back to keep context.
Sessions expire after 1 hour of inactivity.
Follow-up
curl -X POST "$BASE/chat?token=$VIANEXUS_TOKEN&session_id=5f942fb6fadf4791bc7dece76d4a7332" \
-H "Content-Type: application/json" \
-d '{"message": "How does that compare to its 52-week high?"}'
Drop into any app, terminal, or workspace.
Speaks directly to the viaNexus MCP.
Dataset permissions are enforced through the same MCP token flow.
Per-conversation billing, marketplace-ready.
Financial Chat Agent uses the same viaNexus account token and dataset permissions as the rest of vAST. If your pk_... token can reach a dataset, the agent can use it.
Token
Account and subscribed datasets.
/chat
Question arrives with ?token=.
Answer
Only allowed datasets.
Same permission model
The agent does not bypass subscriptions. It can only answer from datasets your token is allowed to access.
OpenBB
Add Financial Chat Agent manually to an OpenBB workspace. Users get conversational access to 30+ institutional datasets, with charts, alerts, and tables rendered alongside OpenBB’s native widgets. The marketplace listing is MCP-only for now; the full agent is available today via manual install.
Watch demoConversational portfolio analysis. Natural language across every subscribed dataset, in one chat.
Dynamic chart creation. Charts and dashboards generated on demand inside OpenBB widgets.
Automated monitoring & alerting. Set alerts on any condition; data payloads delivered to email.
Entitlement-aware. The agent uses the same MCP token and dataset-permission enforcement as the connector.
Chatbot
Drop Financial Chat Agent into your app, portal, or website as a chat interface. Users type questions, the agent queries your viaNexus data and responds with structured answers, tables, and charts. AskNexus is the live working example, that’s exactly this use case, built and running today.
Try AskNexusSee vianexus.com/asknexus for the working consumer chat we run on Financial Chat Agent. The same agent, with the same auth and dataset-permission model, embedded against the full viaNexus catalog. Build the same thing in your product.
Agent SDK
Open-source Python framework. Bring your LLM, bring your infra, write your code. MIT-licensed, Python 3.11+.
Unified factory for OpenAI, Anthropic, and Gemini. Built-in memory stores, persistent MCP sessions, automatic tool integration with the viaNexus MCP, OAuth + software-statement auth, full type hints.
Install via pip or uv. The factory auto-detects the LLM provider from your model name, so you can switch providers by changing one config value.
Install
# with uv (recommended)
uv add git+https://github.com/blueskynexus/viaNexus-agent-sdk-python --tag v1.0.0-pre14
# or with pip
pip install git+https://github.com/blueskynexus/viaNexus-agent-sdk-python@v1.0.0-pre14
Quickstart
from vianexus_agent_sdk.clients.llm_client_factory import LLMClientFactory
config = {
"LLM_MODEL": "gpt-4o-mini",
"LLM_API_KEY": os.getenv("OPENAI_API_KEY"),
"agentServers": {
"viaNexus": {
"server_url": "https://vast-mcp.blueskyapi.com",
"server_port": 443,
"software_statement": os.getenv("VIANEXUS_JWT"),
}
},
}
client = LLMClientFactory.create_client(config)
await client.initialize()
response = await client.ask_question("Get Tesla's latest earnings")
await client.cleanup()
01 / 05
From your viaNexus account, request a software statement with the dataset patterns this agent can reach. For a news agent, include EDGE:MT_NEWSWIRES*.
The API returns a signed JWT. The SDK presents that JWT during MCP OAuth registration, and the MCP server enforces those permissions server-side.
Request
curl -X POST "https://api.blueskyapi.com/v1/agents/register?token=$VIANEXUS_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"expiresIn":"1h",
"permissions":{"include":["EDGE:MT_NEWSWIRES*"]}}'
Response
{
"success": true,
"softwareStatement": "eyJhbGciOiJSUzI1NiIs..."
}
Save it as VIANEXUS_JWT in your env.
One install pulls the framework, the MCP client, and the OAuth handler. No additional setup, no separate auth library.
Python 3.11+. We recommend uv for speed, but pip works just as well.
Recommended
uv add git+https://github.com/blueskynexus/viaNexus-agent-sdk-python \
--tag v1.0.0-pre14
Or with pip
pip install git+https://github.com/blueskynexus/viaNexus-agent-sdk-python@v1.0.0-pre14
What You Get
LLMClientFactory, persistent MCP session manager, OAuth handler, three memory backends, full type hints.
One config dict. Pick a model, drop in the JWT from step 01, and let the factory wire up OAuth, MCP, and tool integration for you.
Switch providers later by changing the model name, the factory auto-detects Anthropic, OpenAI, or Google.
Auto-wired tools
The factory registers search and fetch with the LLM. Claude decides when to call them.
news_agent.py
from vianexus_agent_sdk.clients.llm_client_factory import LLMClientFactory
import os, asyncio
config = {
"LLM_MODEL": "claude-3-5-sonnet-20241022",
"LLM_API_KEY": os.getenv("ANTHROPIC_API_KEY"),
"system_prompt": "You are a financial news analyst.",
"agentServers": {
"viaNexus": {
"server_url": "https://vast-mcp.blueskyapi.com",
"server_port": 443,
"software_statement": os.getenv("VIANEXUS_JWT"),
}
},
}
async def main():
client = LLMClientFactory.create_client(config)
await client.initialize()
answer = await client.ask_question(
"What did Powell say about rates this week?"
)
print(answer)
await client.cleanup()
asyncio.run(main())
The SDK presents your software statement to the auth server, gets a scoped access token, opens an MCP session, and exposes search + fetch to Claude.
Claude decides when to call them. The agent loop runs until the answer is ready, then closes the session.
Run
$ python news_agent.py
What happens, in order
search and fetch registered with Claudesearch for Powell rate-related newsfetch for the matching articlesTry the boundary
Ask about REPORTED_FINANCIALS: the MCP returns a permission error for CORE:REPORTED_FINANCIALS. Your software statement only allowed news, so the call is rejected server-side.
Subscribe to a fundamentals dataset later? Issue a new software statement with a broader permissions.include list.
Reconnect or refresh the client with the new statement. Code stays the same. The auth flow stays the same.
Add a dataset
Issue a new statement with broader permissions.
permissions: {
include: [
"EDGE:MT_NEWSWIRES*",
"CORE:REPORTED_FINANCIALS:*"
]
}
Swap providers
Change one config key.
"LLM_MODEL":
"gpt-4o-mini"
# → OpenAI auto-detected
Persist memory across runs
client = LLMClientFactory.create_client_with_memory(
config, memory_type="file", path="./agent.db"
)
The auth flow is unchanged. New permission patterns, new providers, new memory backends, all behind the same SDK config shape.
Three major providers, one unified interface. The factory detects the provider from the model name (or you can set it explicitly). Switching providers is a config change, no code rewrite.
OpenAI
GPT-4, GPT-4o, o1.
Detect: gpt-*, o1-*
Anthropic
3.5 Sonnet, 3 Opus, 3 Haiku.
Detect: claude-*
2.5 Flash, Pro, more.
Detect: gemini-*
Switch providers without code changes
# Auto-detect from model name
config["LLM_MODEL"] = "claude-3-5-sonnet-20241022" # → Anthropic
config["LLM_MODEL"] = "gemini-2.5-flash" # → Gemini
config["LLM_MODEL"] = "gpt-4o-mini" # → OpenAI
# Or pin explicitly
client = LLMClientFactory.create_client(config, provider="anthropic")
Three memory modes, picked per agent. Memory is session-isolated by user_id so multi-tenant deployments don’t cross-contaminate, and the same store works across all three providers.
Tier 01
DefaultSession-only. Lost on restart.
with_in_memory_store()
Tier 02
PersistentPersists across restarts. Multi-day analyst sessions.
with_file_memory_store(path)
Tier 03
NoneNo history. One-shot lookups, batch jobs.
without_memory()
Per-call memory control
response = await client.ask_question(
"What is Apple's market cap?",
maintain_history=True, # keep in current session context
use_memory=True, # persist to / load from store
load_from_memory=True, # hydrate prior conversation
)
Cross-provider memory: a conversation started with Claude can be continued with GPT-4o, the store is provider-agnostic. Useful for cost optimization (cheap model for triage, premium for synthesis) without losing context.
For long-running conversations, the persistent client keeps a single MCP session alive across many queries. The MCP handshake (discovery, registration, OAuth, introspection) happens once instead of per-request, lower latency, lower load on the auth server.
OAuth once at session start. Tool calls reuse it.
Pair with file memory for multi-day sessions.
is_connected, mcp_session_id for monitoring.
auto_establish_connection=True for auto-reconnect.
Long-running portfolio session
client = LLMClientFactory.create_persistent_client(config)
await client.initialize()
session_id = await client.establish_persistent_connection()
r1 = await client.ask_with_persistent_session(
"Analyze AAPL recent performance",
maintain_history=True, use_memory=True,
)
r2 = await client.ask_with_persistent_session(
"Compare it with MSFT",
maintain_history=True, use_memory=True,
)
await client.close_persistent_connection()
await client.cleanup()
No special setup. Every client created through the factory automatically registers viaNexus MCP tools (search, fetch) with the LLM. The model decides when to call them; the SDK routes calls through the MCP, applies dataset permissions, and returns structured data.
client = LLMClientFactory.create_client(config)
await client.initialize()
# The LLM decides when to call MCP tools, no manual orchestration
response = await client.ask_question(
"Get Tesla's latest earnings and calculate key financial ratios"
)
# 1. LLM calls `search` to find the right dataset
# 2. LLM calls `fetch` to retrieve earnings rows
# 3. LLM analyzes the data and computes ratios
# 4. Returns the synthesized answer
The agent only sees datasets your software statement allows. Same dataset-permission model as the MCP service, the SDK is a thin client over it.
All clients implement the same interface regardless of provider. Persistent clients add session lifecycle methods on top.
| Method | Use case |
|---|---|
| initialize() | Set up MCP connection. Required before any query. |
| ask_single_question(q) | One-shot query, no history. Quick lookups. |
| ask_question(q, ...) | Flexible query with history / memory toggles. Most common. |
| process_query(q) | Streaming output with maintained history. Real-time UIs. |
| cleanup() | Tear down connections. Required at shutdown. |
| establish_persistent_connection() | Persistent client, open long-running MCP session. |
| ask_with_persistent_session(q, ...) | Persistent client, query within the open session. |
| close_persistent_connection() | Persistent client, close the session cleanly. |
The SDK is general-purpose. Three concrete patterns, each plugs into the same MCP server, and the permission layer limits access to what its software statement allows.
News agent
Software statement scoped to MT Newswires, CityFalcon, or both, nothing else. Drop-in for apps that need a single-purpose news layer.
Fundamentals agent
Knows reported financials, normalized statements, EPS forecasts, nothing about news or pricing. The narrowest possible scope, full depth.
Custom Financial Chat Agent
Same kind of full-coverage agent we productize as Financial Chat Agent, on your own infra, your own LLM, your own memory layer, your own UI. The SDK gives you the pieces; you assemble.
The SDK code is free and MIT-licensed. To reach data you need a viaNexus account, software statements are issued from your account, and the MCP server only serves agents whose statements it can validate.
GitHub repoDataset Catalog
The catalog shows what an agent can actually access: NexusCore datasets are included with every plan, while NexusEdge partner datasets can be added one subscription at a time. Your software statement and token permissions enforce that access across MCP, Financial Chat Agent, and the SDK.
NexusCore
14
bundled datasets
NexusEdge
16+
premium add-ons
Partners
7+
data providers
Data Partners
Premium partner data flowing through viaNexus today. Each partner is reachable via the universal MCP, or, where supported, through their own pre-listed Claude connector.
MT Newswires
Real-time financial news
Claude libraryAiera
Earnings call transcripts
Universal MCPBMLL
Pre-trade analytics
Universal MCPExtractAlpha
EPS & revenue forecasts
Universal MCPIndexOne
Custom indices
Universal MCPSavaNet
Standardized fundamentals
Universal MCPBecome a partner →
List your data on viaNexus
Get in touchComing soon
CityFalcon
News & sentiment
Coming soonPrediction Markets
via Open Data Minds
PlannedBundled with every plan, available to every subscriber by default.
Your dataset joins the catalog alongside NexusCore + NexusEdge, reachable through MCP, Financial Chat Agent, and SDK without you rebuilding licensing or auth.
Become a data partnerIf you publish financial data, vAST is a distribution channel into AI agents. You bring data; viaNexus handles the MCP, OAuth, dataset permissions, and billing.
Normalization
Schema mapping into the viaNexus standard.
Concordance
Entity resolution across providers and identifiers.
Access control
OAuth, software statements, dataset-permission patterns, commercial vs. personal, geo, rate limits.
Monetization
Subscriptions, billing, and usage metering. Transparent revenue share.
Resources
Demos, articles, and skill packs. Install one in Claude, pair with the viaNexus MCP, run on real dataset permissions.
Short demos for setting up vAST connectors, dashboards, and agent workflows.
More on YouTube →
Add the viaNexus MCP to Claude and make your first query.
Walkthrough
Dashboard, death-cross alert, datasets, and Paygentic billing.
Demo
Interactive dashboards powered by viaNexus data.
DemoSelected viaNexus articles for agent builders, data engineers, and MCP users.
View all on blog →viaNexus extends MCP with scoped, signed credentials for financial data. Works with Claude, Cursor, and any MCP client.
Whether you’re vibe-coding an app at home — or building a professional GPT to support finance professionals — you need reliable, verified, authoritative data delivered in a form your project can effortlessly consume. That's where viaNexus Agentic Services Technology (vAST) comes in.
From a bold idea and a bare-bones plan to a live, high-performance marketplace, 2025 was the year viaNexus proved a new model for market data and agentic workflows isn’t just possible—it’s necessary. We’re heading into 2026 ready to scale!
LLMs can’t be trusted with math—or data scraped from the web. viaNexus and vAST eliminate hallucination from the ground up with licensed, structured, and precalculated data. Deterministic, auditable, and built for finance—where “close enough” isn’t good enough.
AI agents are poised to revolutionize industries, but the true potential of these autonomous entities is often obscured by "AI Agent Washing"—a deceptive practice that misrepresents a system's capabilities.
This article details viaNexus' Agentic Workflow service, extending OAuth 2.0/2.1 to enable scalable, autonomous agents in finance. It overcomes traditional OAuth's limits with pre-authorized scopes, and securing agent authentication and authorization.
Agentic workflows, designed to automate complex tasks, hold immense promise for boosting productivity and efficiency. However, current implementations face several significant shortcomings that hinder their full potential. This blog post will explore these challenges, particularly foc...
Pre-built skills for Claude live in GitHub. Clone into ~/.claude/skills/, or open Raw on each skill and paste the SKILL.md into Claude with "Please save this as a skill.", then pair with the viaNexus MCP connector for live data.
Featured demo
30+ datasets, OpenBB workspace, Paygentic billing, in minutes.
Latest from the blog
View all →Building dashboards and AI agents on 30+ institutional datasets through one API.
How viaNexus + SavaNet turned XBRL chaos into structured financial schema.
Combining six viaNexus datasets into one earnings dashboard.
How MCP makes financial data accessible to any AI agent.
14-day free trial. No credit card. Connect to 30+ financial datasets through your AI in under two minutes.
Or jump to the MCP quickstart if you already have an account.