Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Flexo CLI – A command-line interface for traders and developers to run instant analytics, deploy AI agents, and automate blockchain interactions.
Flexo SDK – A developer toolkit for integrating Flexo’s AI-powered blockchain analytics directly into applications.
Flexo CLI is a lightweight, high-performance command-line tool that allows users to analyze tokens, create AI agents, and automate DeFi strategies directly from their terminal.
Real-time Solana token analytics – Get instant insights on token liquidity, risk levels, and smart contract behavior.
AI agent deployment – Define and launch AI-driven blockchain agents with a few lines of code.
Privacy-first execution – All commands run locally without logging or tracking.
Run a command
Users interact with Flexo via simple CLI commands.
AI-powered processing
Users interact with Flexo via simple CLI commands.
1.3 Example CLI Commands
Flexo SDK is a developer-friendly toolkit that enables applications to integrate real-time blockchain analytics and AI-powered automation. It provides fast, secure API calls for interacting with Solana’s on-chain data.
AI-powered blockchain analytics – Integrate token scoring, risk assessment, and liquidity tracking into any application.
Seamless application integration – Supports JavaScript, TypeScript, and other frameworks.
Efficient blockchain queries – Fetches on-chain Solana data without relying on centralized services.
Install the SDK – Developers integrate Flexo into their project using npm or yarn.
Use Flexo API calls – Fetch real-time blockchain data and AI-driven insights with simple functions.
Build AI-driven applications – Automate token analysis, trading strategies, and risk monitoring.
Example SDK Usage
Flexo offers two powerful ways to interact with blockchain data and AI automation:
Flexo CLI for instant insights and AI agent management in the terminal.
Flexo SDK for seamless integration into applications and automated workflows.
By combining speed, privacy, and AI-powered intelligence, Flexo provides traders and developers with the tools they need to analyze, automate, and innovate on Solana—without relying on third parties.
All insights are delivered directly in your CLI, ensuring fast, private execution.
# Analyze a token instantly
npm run flexo check <token-address>
# Deploy an AI agent on Solana
npm run flexo deploy
# Get real-time token price
npm run flexo price <token-address>typescriptCopyEditimport FlexoClient from 'flexo-sdk';
const client = new FlexoClient();
// Fetch token analytics
const analysis = await client.getToken('your-token-address');
console.log(`Token Score: ${analysis.data.score}`);
// Deploy an AI agent
const response = await client.deployAgent({ name: 'MarketBot', strategy: 'risk-analysis' });
console.log(`Agent deployed: ${response.data.id}`);Flexo CLI is a lightweight, high-performance command-line tool that allows users to analyze tokens, create AI agents, and automate DeFi strategies directly from their terminal.
Real-time Solana token analytics – Get instant insights on token liquidity, risk levels, and smart contract behavior.
AI agent deployment – Define and launch AI-driven blockchain agents with a few lines of code.
Privacy-first execution – All commands run locally without logging or tracking.
Direct blockchain access – Queries are sent straight to Solana nodes, bypassing third-party APIs.
Run a command
Users interact with Flexo via simple CLI commands.
AI-powered processing
Users interact with Flexo via simple CLI commands.
All insights are delivered directly in your CLI, ensuring fast, private execution.
Architecture
# Analyze a token instantly
npm run flexo check <token-address>
# Deploy an AI agent on Solana
npm run flexo deploy
# Get real-time token price
npm run flexo price <token-address>We've designed a minimal, single-page demo to help you get started with the Flexo API. This demo showcases token analysis and AI agent interactions in action, giving you a practical example of how to integrate our powerful API into your application.
The Flexo API Demo is open-source and provides a great starting point for learning how to interact with our API. It features a simple implementation of:
Real-time token analysis AI-driven agent interactions for risk assessment and market trends
Whether you're new to API integration or looking to quickly test out our features, this demo offers everything you need to understand the fundamentals of Flexo in just a few steps.
Check out the full open-source repository for the demo, including setup instructions and detailed usage examples: https://github.com/flexosh/api-usage-example
Market metrics and valuation
Liquidity pool analysis
Ownership distribution
Deployment details
Audit risk factors
Returns all available AI agents with their capabilities:
Agent identification
Supported analysis types
Specialization areas
System configuration
Returns detailed information about a specific AI agent:
Complete agent profile
Available capabilities
System configuration
Specialization details
Interactive conversation with AI agents, allowing:
Token analysis requests
Risk assessment queries
Market insights
Custom analysis requests
GET /v1/token/:addressinterface TokenData {
address: string;
tokenName: string;
tokenSymbol: string;
tokenImg: string;
score: number;
deployTime: string;
marketCap: number;
externals: string;
price: string;
supplyAmount: number;
mktCap: number;
auditRisk: {
mintDisabled: boolean;
freezeDisabled: boolean;
lpBurned: boolean;
top10Holders: boolean;
};
tokenOverview: {
deployer: string;
mint: string;
address: string;
type: string;
};
indicatorData: {
high: { count: number; details: string };
moderate: { count: number; details: string };
low: { count: number; details: string };
specific: { count: number; details: string };
};
liquidityList: Array<Record<string, {
address: string;
amount: number;
lpPair: string;
}>>;
ownersList: {
address: string;
amount: string;
percentage: string;
}[];
}GET /v1/agentsinterface Agent {
id: string;
name: string;
description: string;
capabilities: ('token_analysis' | 'market_analysis' | 'risk_assessment')[];
}GET /v1/agents/:idPOST /v1/agents/:id/chat{
"messages": [
{
"role": "user" | "assistant" | "system" | "function",
"content": "string",
"name": "string (optional)"
}
]
}interface AgentResponse {
response: string; // AI-generated analysis
timestamp: string; // Response timestamp
}Windows Subsystem for Linux (WSL) provides a seamless way to run a Linux environment on Windows, enabling developers to work with Flexo SDK efficiently. This guide walks you through setting up WSL, installing dependencies, and running Flexo SDK on your Windows machine.
Before installing Flexo SDK on WSL, ensure you have:
Windows 10 (version 2004+) or Windows 11
WSL 2 installed and configured
Node.js and npm (or yarn) installed in WSL
If you haven’t already set up WSL, install it using the following command in PowerShell (Admin):
This will:
Enable WSL 2
Install Ubuntu (default distribution)
To check the installed version, run:
If WSL is already installed but not using WSL 2, upgrade it:
Once WSL is installed, open Ubuntu from the Start Menu and update the system:
To install Node.js (LTS) and npm, run:
Verify installation:
Alternatively, you can use nvm (Node Version Manager) for managing multiple Node.js versions:
With Node.js and Solana CLI installed, you can now install Flexo SDK:
Now you can start using Flexo SDK inside WSL.
Run the script with:
wsl --installwsl --list --verbosewsl --set-version Ubuntu 2sudo apt update && sudo apt upgrade -ycurl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejsnode -v
npm -vcurl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash
source ~/.bashrc
nvm install 18
nvm use 18npm install flexo-sdk
# or
yarn add flexo-sdkimport FlexoClient from 'flexo-sdk';
async function analyzeToken(address: string) {
const client = new FlexoClient();
const analysis = await client.getToken(address);
console.log(`Token Score: ${analysis.data.score}`);
}
analyzeToken('your-token-address');node script.jsFlexo is built with privacy as a core principle. Unlike cloud-based analytics platforms that log queries, track user behavior, or require API keys, Flexo operates locally in your own CLI, ensuring that your data is never stored, analyzed, or shared. Every request runs on your system, keeping full control in your hands.
Flexo is optimized for instant execution, eliminating delays from external APIs, network congestion, or centralized rate limits. Whether retrieving token health, liquidity, or risk scores or executing AI-driven decisions, Flexo delivers real-time insights instantly in your CLI.
Flexo ensures end-to-end encryption for all queries and AI agent interactions. With parallel processing and efficient data handling, it supports thousands of real-time blockchain requests without performance slowdowns, keeping both traders and developers ahead of the market.
Flexo allows users to create and deploy AI agents directly on Solana. With just a few lines of code, you can define an agent’s behavior and purpose, customize its capabilities, and automate DeFi strategies, market analysis, and smart contract interactions—all from your own terminal.
Flexo connects directly to Solana RPCs and blockchain nodes, ensuring that users receive raw, verifiable, and unfiltered data. Unlike third-party services that filter or manipulate data, Flexo provides authentic blockchain insights straight to your terminal, maintaining accuracy and transparency.
Flexo is designed for CLI, API, and SDK integration, making it easy for developers to train and deploy AI agents, automate token analysis, and integrate blockchain intelligence into applications. Whether you're working on market prediction, risk assessment, or automated trading, Flexo handles everything directly from your command line.
Built exclusively for Solana, Flexo is optimized for Windows, Linux, and remote servers, allowing users to run blockchain analytics and AI automation anywhere, anytime, directly in their CLI. No cloud dependencies, no third-party access—just fast, private, and AI-driven blockchain automation.
Flexo unlocks powerful capabilities for DeFi innovation, enabling automation, risk assessment, and AI-driven decision-making. Below are some key use cases with real-world implementation examples.
Flexo helps automate portfolio management by continuously analyzing token performance and adjusting holdings based on risk scores and market trends.
Continuous Monitoring – Use
getToken()to track token performance in real-time. Automated Adjustments – Implement logic to rebalance portfolios based on risk scores.
Leverage AI-driven predictive analytics to forecast market trends and detect potential market shifts before they happen.
AI-Driven Predictions – Use the
chat()method for real-time market forecasts. Early Warning System – Implement AI-powered alerts for trend shifts.
Flexo enables data-driven insurance underwriting by assessing the risk of insuring specific tokens or portfolios.
Risk Evaluation – Use
getToken()to analyze risk before underwriting policies. Dynamic Pricing – Adjust insurance premiums based on token risk scores.
Optimize liquidity management by analyzing token performance and dynamically adjusting liquidity pool contributions.
Liquidity Analysis – Use
getToken()to monitor liquidity health. Automated Adjustments – Optimize liquidity allocation based on risk assessments.
These examples showcase how Flexo’s AI and analytics capabilities can be leveraged for:
✅ Automated DeFi strategies ✅ Risk management ✅ Real-time decision-making
Whether managing portfolios, predicting market trends, underwriting insurance, or optimizing liquidity, Flexo provides the tools to innovate in DeFi with confidence.
Below is a system flow diagram illustrating how Flexo processes user input, routes functions, gathers data, and generates responses.
Flexo processes user requests through a modular AI-driven system. Each request follows this journey:
1️⃣ User Input – A request comes through the CLI, API, or SDK. 2️⃣ Flexo AI Agent – Interprets and routes the request. 3️⃣ Function Router – Decides which data sources to call. 4️⃣ Data Processing – Fetches blockchain data, external market insights, and AI analysis. 5️⃣ Response Generator – Formats the data and sends it back to the user
Flexo is built for reliability and security, incorporating:
Parallel Processing – Handles thousands of simultaneous requests. Rate Limiting – Prevents API abuse and ensures fair access. End-to-End Encryption – Protects sensitive data and transactions.
Flexo is built for traders, developers, and enterprises who require real-time blockchain insights. By combining AI-powered analytics, fast execution, and powerful integrations, Flexo empowers users to make data-driven decisions with confidence.
Flexo SDK is a developer-friendly toolkit that enables applications to integrate real-time blockchain analytics and AI-powered automation. It provides fast, secure API calls for interacting with Solana’s on-chain data.
AI-powered blockchain analytics – Integrate token scoring, risk assessment, and liquidity tracking into any application.
Seamless application integration – Supports JavaScript, TypeScript, and other frameworks.
Select from AI agents trained in different areas of DeFi Chat naturally to analyze token performance & risks Get real-time blockchain insights without complex queries
For fast token insights without AI agent assistance, use these direct commands:
✅ Ideal for traders & developers who need instant token metrics without launching chat mode.
Flexo lets you create and deploy custom AI agents to automate market analysis, risk assessment, and strategic decision-making.
Define a personalized AI agent tailored to your needs. Run:
During setup, you'll specify:
Agent ID (Unique identifier)
Name & Description (Define its role, e.g., "Market Sage - Expert in trend analysis")
Capabilities (E.g., Token analysis, risk scoring, sentiment tracking)
System Prompt (Custom AI instructions, e.g., "You are an expert in predicting market trends...")
Your AI agent is now ready for local use and can be deployed on-chain later.
Deploy your AI agent to the Solana blockchain for decentralized access.
Creates an SPL token for agent access
Uploads metadata to IPFS for decentralized storage
Initializes a Pump bonding curve for AI agent trading
A Solana wallet with at least 0.1 SOL SOL for deployment fees (~0.05 SOL) SOL for initial liquidity (configurable)
Your agent is now live on Solana and can be accessed via its SPL token.
Flexo CLI gives you full control over AI-driven DeFi analysis—whether through:
Use chat mode for AI-assisted analysis
Run quick commands for fast token insights
Create & deploy AI agents for automated market strategies
Install the SDK – Developers integrate Flexo into their project using npm or yarn.
Use Flexo API calls – Fetch real-time blockchain data and AI-driven insights with simple functions.
Build AI-driven applications – Automate token analysis, trading strategies, and risk monitoring.
Flexo SDK also supports AI-powered agent interactions for deeper risk assessment.
import FlexoClient from 'flexo-sdk';
async function managePortfolio(tokenAddresses: string[]) {
const client = new FlexoClient();
const threshold = 50; // Risk score threshold
for (const address of tokenAddresses) {
const analysis = await client.getToken(address);
const action = analysis.data.score < threshold ? 'Sell' : 'Hold';
console.log(`${action}: ${analysis.data.tokenName}`);
}
}
managePortfolio(['token1', 'token2', 'token3']);import { FlexoClient, ChatMessage } from 'flexo-sdk';
async function predictiveMarketAnalysis(agentId: string) {
const client = new FlexoClient();
const messages: ChatMessage[] = [{ role: 'user', content: 'Predict market trends for token ABC' }];
const response = await client.chat(agentId, messages);
console.log('Market Prediction:', response.data.response);
}
predictiveMarketAnalysis('agent-id');import FlexoClient from 'flexo-sdk';
async function underwriteInsurance(tokenAddress: string) {
const client = new FlexoClient();
const analysis = await client.getToken(tokenAddress);
const riskLevel = analysis.data.score < 50 ? 'High' : 'Low';
const premium = riskLevel === 'High' ? 0.05 : 0.02; // Example premium rates
console.log(`Token: ${analysis.data.tokenName}, Risk Level: ${riskLevel}, Premium: ${premium}`);
}
underwriteInsurance('token-address');import FlexoClient from 'flexo-sdk';
async function adjustLiquidity(tokenAddress: string) {
const client = new FlexoClient();
const analysis = await client.getToken(tokenAddress);
if (analysis.data.liquidity < 10000) { // Example liquidity threshold
console.log(`Adding liquidity to: ${analysis.data.tokenName}`);
// Implement liquidity addition logic
} else {
console.log(`Liquidity is sufficient for: ${analysis.data.tokenName}`);
}
}
adjustLiquidity('token-address');npm run flexonpm run flexo check <token-address> # Get token health & risk analysis
npm run flexo stats <token-address> # View token liquidity & market data
npm run flexo price <token-address> # Fetch real-time price infonpm run flexo create? Enter agent ID: market-sage
? Enter agent name: Market Sage
? Enter agent description: Expert in market dynamics and trend analysis
? Select capabilities: Token Analysis
? Enter system prompt: You are an expert in analyzing market trends...
✅ Agent successfully created!
📂 Saved in: data/agents.jsonnpm run flexo deployDeploying agent: Market Sage...
✅ Transaction: https://solscan.io/tx/2r1ZF...
✅ Mint Address: BKyz7...
✅ Deploy Link: https://pump.fun/coin/BKyz7...npm install flexo-sdk
# or
yarn add flexo-sdkimport FlexoClient from 'flexo-sdk';
// Initialize the client
const client = new FlexoClient();
// Analyze a token
const analysis = await client.getToken('token-address');
console.log(`Token Score: ${analysis.data.score}`);import FlexoClient from 'flexo-sdk';
async function analyzeToken(address: string) {
const client = new FlexoClient();
const analysis = await client.getToken(address);
console.log(`
Token Analysis:
------------------------
Name: ${analysis.data.tokenName}
Score: ${analysis.data.score}/100
Market Cap: $${analysis.data.marketCap}
Risk Level: ${analysis.data.score < 50 ? 'High' : 'Low'}
LP Burned: ${analysis.data.auditRisk.lpBurned ? 'Yes' : 'No'}
`);
}import { FlexoClient, ChatMessage } from 'flexo-sdk';
async function chatWithAgent() {
const client = new FlexoClient();
const messages: ChatMessage[] = [
{ role: 'user', content: 'Analyze the risk factors for token ABC' }
];
const response = await client.chat('agent-id', messages);
console.log('AI Analysis:', response.data.response);
}
chatWithAgent();This gives you access to the full Flexo CLI framework, ready for installation.
Never expose your API keys or private wallet keys in public repositories. Use .gitignore to prevent the .env file from being committed, and consider secure storage solutions like AWS Secrets Manager or environment variable encryption.
npm install# Generate new keypair
solana-keygen new --outfile ~/.config/solana/flexo-wallet.json
# Set default wallet
solana config set --keypair ~/.config/solana/flexo-wallet.json
# Verify wallet setup
solana address
solana balanceOPENAI_API_KEY=<your-openai-api-key>
SOL_WALLET_KEY=<your-wallet-private-key>
API_URL=https://api.flexo.sh
SOLANA_RPC_URL=https://api.mainnet-beta.solana.comnpm run flexogit clone https://github.com/flexosh/cli.git
cd flexo-cliFlexo Framework is an AI-powered, privacy-first CLI framework designed for real-time blockchain analytics and AI agent creation on Solana. Whether you're a trader looking for instant token insights or a developer building custom AI agents, Flexo gives you direct access to blockchain data and AI automation, all within your own CLI, without relying on third-party services.
For Traders - Flexo Frameworkdelivers real-time token insights and risk assessment instantly in your CLI. No need to browse multiple dashboards or rely on slow APIs, just run a command and get instant, AI-driven analytics to make faster, data-backed trading decisions.
For Developers - Flexo Framework handles AI agent creation, deployment, and blockchain queries so you don’t have to. Token scoring, liquidity tracking, risk assessment—done.
Windows or Linux - Flexo Framework works on both, but for Linux users, it’s a faster, more efficient way to explore the blockchain, run real-time analytics, and automate DeFi strategies without leaving the terminal.
Building Apps - Integrate Flexo Framework SDKs and get real-time market data directly into your app. No extra work, no complexity, just AI-powered insights.
Start using Flexo in just a few steps. Install our CLI on Windows, Linux, or a remote server and get instant access to our tools. Check the pages below for detailed setup instructions.
Integrate Flexo SDK and get real-time token analytics right in your app. Quick setup, easy API calls, and instant blockchain data. Check the pages below to get started.
