A comprehensive full-stack Web3 platform featuring Neo Glow design, AI-powered agents, and complete blockchain integration for the Solana ecosystem.

• Next.js 15 App Router with TypeScript
• Neo Glow Design System: glowing borders, neon accents, glassmorphism
• Tailwind CSS with custom glow utilities
• Fully responsive (desktop, tablet, mobile)
• Dashboard for all blockchain operations

• Local Windows application for platform administration
• Complete agent management (create, pause, resume, configure)
• User management with credits, plans, and account controls
• Billing system (Stripe + crypto payment tracking)
• Fee configuration and overrides
• Infrastructure management (RPC endpoints, oracles, wallets)
• Add-ons and SDK/API key management
• Comprehensive audit logging
• Secure admin-only access with service role key

Note: Admin panel screenshots will be added after initial deployment. To see the admin interface:

1. Navigate to admin-tauri/
2. Configure .env with your Supabase service role key
3. Run npm run tauri:dev
4. The admin panel will launch as a desktop application

• Real-time database with PostgreSQL
• Row Level Security (RLS) policies
• Database schemas for:
  • Users & authentication
  • Wallet connections
  • Transaction history
  • Token portfolios
  • NFT collections & metadata
  • DeFi positions
  • AI agent configurations & memory

• One-click Vercel deployment
• Environment variable configuration
• Edge functions and API routes
• Optimized build configuration

• Cross-platform (iOS & Android)
• Neo Glow themed components
• Shared types and API client
• Real-time blockchain data

• Windows executable (agentic.exe)
• Full admin UI dashboard
• System tray integration
• Auto-update support
• Node 20.19+ compatible

• Deploy SPL tokens via Metaplex
• Transfer assets
• Balance checks
• Stake SOL
• ZK compressed Airdrop (Light Protocol)
• Jupiter, Raydium, Kamino, Helius integrations

• Metaplex: Collection deployment, minting, metadata
• 3.Land: Create collections, list NFTs for sale in any SPL token
• Royalty configuration
• Automatic marketplace listing

• Jupiter: Best price swaps
• PumpPortal: Token launches
• Raydium: CPMM, CLMM, AMMv4 pools
• Orca: Whirlpool integration
• Meteora: Dynamic AMM, DLMM, Alpha Vault
• Kamino: Lending and yield
• Drift: Perps, vaults, lending
• Manifest: Market creation, limit orders
• Openbook: Market creation
• Jito Bundles: MEV protection
• deBridge DLN: Cross-chain bridging

• Lulo lending (best USDC APR)
• Arcade games
• JupSOL staking
• Solayer sSOL staking

• SNS domain registration/resolution
• Alldomains registration
• Gib Work bounty registration
• Perpetuals trading (Adrena)

• CoinGecko Pro API: Real-time prices, trends, top gainers
• Pyth Network: High-fidelity oracle price feeds
• Token information lookup
• Pool tracking

• Ready-to-use blockchain tools
• Autonomous agent support
• Memory management
• Streaming responses

• Framework-agnostic AI
• Quick toolkit setup
• Real-time streaming

• DALL-E NFT artwork generation
• Natural language blockchain commands
• Price feed integration
• Automated decision-making
• Interactive & autonomous modes

Agentic/
├── src/                    # Next.js 15 web app (App Router)
│   ├── app/               # Pages and API routes
│   │   ├── layout.tsx     # Root layout with ErrorBoundary
│   │   ├── page.tsx       # Home page
│   │   ├── dashboard/     # Dashboard page
│   │   ├── tokens/        # Token operations
│   │   ├── nfts/          # NFT management
│   │   ├── defi/          # DeFi integrations
│   │   ├── market/        # Market data
│   │   ├── ai-agent/      # AI agent chat interface
│   │   └── api/           # API routes (ai, balance, market)
│   ├── components/        # React components
│   │   ├── ui/            # Button, Card, Input (Neo Glow)
│   │   ├── layout/        # Navbar (responsive)
│   │   └── ErrorBoundary.tsx  # React error boundary
│   ├── lib/               # Server/client libraries
│   │   ├── solana/        # Solana client, DeFi, NFT
│   │   ├── ai/            # LangChain, DALL-E
│   │   ├── market/        # CoinGecko client
│   │   ├── supabase/      # Supabase client
│   │   ├── env.ts         # Zod env validation
│   │   └── utils.ts       # Shared utilities
│   ├── services/ai/       # AI service layer
│   │   ├── index.ts       # Server-only entry (server-only guard)
│   │   ├── utils.ts       # Client-safe utilities
│   │   ├── rate-limiting  # Request rate limiter
│   │   ├── fallback-handlers # Provider fallback chain
│   │   ├── token-tracking # OpenAI usage tracking
│   │   └── prompt-optimization # Prompt engineering
│   └── styles/            # globals.css (Neo Glow design system)
├── admin-tauri/           # Tauri desktop admin panel
│   ├── src/main/          # Supabase commands (TypeScript)
│   ├── src/ui/screens/    # 11 admin screens (React)
│   └── src-tauri/         # Rust backend
├── mobile/                # React Native/Expo scaffold
├── desktop/               # Electron scaffold
├── config/                # Multi-chain configuration
├── supabase/migrations/   # Database schema migrations
├── tests/unit/            # Vitest unit tests (38 tests)
├── docs/                  # Documentation suite
└── .github/workflows/     # CI/CD pipelines

• Node.js 20.19+ or 22.12+ (required by Vite/Vitest)
• npm 10+
• Supabase account
• Solana wallet
• API keys (optional, see .env.example)

1. Clone the repository

git clone https://github.com/SMSDAO/Agentic.git
cd Agentic

2. Install dependencies

npm install

3. Set up environment variables

cp .env.example .env

Edit .env and add your API keys:

• Supabase URL and keys
• Solana RPC URL
• OpenAI API key (for AI features)
• CoinGecko API key (optional)
• Other service API keys as needed

4. Run the development server

npm run dev

Open http://localhost:3000 in your browser.

1. Create a new Supabase project
2. Run the migrations:

npm run supabase:start

The database schema will be automatically created from supabase/migrations/.

cd mobile
npm install
npm start

Use Expo Go app on your phone or run in a simulator.

cd desktop
npm install
npm run dev

To build the Windows executable:

npm run make

The agentic.exe will be in the out directory.

The admin panel is a separate Tauri desktop application for platform administration.

cd admin-tauri
npm install
cp .env.example .env

Edit .env and add your Supabase service role key (required for admin operations):

VITE_SUPABASE_URL=https://your-project.supabase.co
VITE_SUPABASE_ANON_KEY=your-anon-key
VITE_SUPABASE_SERVICE_ROLE_KEY=your-service-role-key

Run the admin panel:

npm run tauri:dev

Build for production:

npm run tauri:build

• Agents: Create, configure, pause/resume AI agents with schedules
• Users: Manage users, adjust credits/plans, freeze accounts
• Billing: View subscription plans, invoices, process refunds
• Fees: Configure global and per-user/per-agent fees
• Infrastructure: Manage wallet connectors, price oracles, RPC endpoints
• Add-ons: Install and configure platform extensions
• SDK/API: Generate and manage API keys with scopes
• Logs: View comprehensive audit trail
• Settings: Configure global platform settings

Security Note: The admin panel requires the Supabase service role key, which has full database access. Never expose this key publicly or commit it to version control. Run the admin panel only on secure, trusted machines.

1. Push your code to GitHub
2. Import project in Vercel
3. Add environment variables
4. Deploy!

Or use Vercel CLI:

vercel deploy

Add these in Vercel dashboard:

• NEXT_PUBLIC_SUPABASE_URL
• NEXT_PUBLIC_SUPABASE_ANON_KEY
• SUPABASE_SERVICE_ROLE_KEY
• OPENAI_API_KEY
• COINGECKO_API_KEY
• See .env.example for complete list

# Run unit tests (38 tests)
npm test

# Watch mode
npm run test:watch

# With coverage report
npm run test:coverage

Unit tests are located in tests/unit/ and cover:

• lib/utils.ts — cn, formatNumber, shortenAddress, formatCurrency
• services/ai/rate-limiting.ts — RateLimiter, createRateLimiter
• services/ai/fallback-handlers.ts — withFallback, FallbackChain
• services/ai/prompt-optimization.ts — buildSystemPrompt, optimizePrompt, truncateToTokenLimit

npm run lint

npm run build

• lib/solana/client.ts: Solana blockchain client
• lib/solana/nft.ts: NFT operations with Metaplex
• lib/solana/defi.ts: DeFi integrations (Jupiter, etc.)
• lib/ai/langchain.ts: LangChain AI agent
• lib/ai/dalle.ts: DALL-E image generation
• lib/market/coingecko.ts: Market data API
• lib/supabase/client.ts: Supabase database client

• /api/balance: Get SOL/token balances
• /api/market: Market data endpoints
• /api/ai: AI agent interactions

The platform features a custom Neo Glow design system with:

• Colors: Neon blue, purple, pink, green, yellow
• Components: Cards, buttons, inputs with glow effects
• Utilities: Custom Tailwind classes for glowing borders, shadows
• Animations: Glow pulse, float effects
• Theme: Dark mode with luminous accents

import { Button } from '@/components/ui/Button';
import { Card } from '@/components/ui/Card';

<Button variant="primary">Glow Button</Button>
<Card className="neo-card">Content</Card>

Screenshots are captured after local deployment. Run npm run dev (web) or cd admin-tauri && npm run tauri:dev (admin) and save images to docs/screenshots/ using the filenames referenced below.

The main dashboard gives users a full portfolio overview in a 4-column stat grid and two detail cards:

SPL token management interface with a Transfer and Deploy Token action bar at the top.

4-column NFT gallery with Upload and Create Collection actions.

4-button quick-action bar (Swap / Liquidity / Stake / Farm) above a protocol card grid.

Real-time market overview with a 3-card header and a sortable token table.

Split-panel layout: chat window (2/3 width) + capabilities sidebar (1/3 width).

The admin panel is a Tauri desktop application (separate from the web app). It connects directly to Supabase using the service role key and provides privileged management screens.

cd admin-tauri
cp .env.example .env   # add SUPABASE_SERVICE_ROLE_KEY
npm install
npm run tauri:dev

Full user registry with inline status and plan badges.

Subscription plan management displayed as a 3-column card grid (Free / Pro / Enterprise), each showing price, feature list, and an edit action.

Platform fee configuration: transaction fee percentage, referral fee, platform cut — editable inline.

Developer portal for managing SDK configurations and API key access.

REST API endpoints exposed by the web app:

Marketplace for enabling optional platform extensions (e.g., extra AI providers, additional oracle feeds, white-label branding).

Chronological log table of all privileged operations.

Global platform configuration: display name, contact email, maintenance mode toggle, feature flags.

1. Web app — npm run dev → navigate to each route → screenshot → save to docs/screenshots/
2. Admin panel — cd admin-tauri && npm run tauri:dev → navigate each screen → screenshot → save to docs/screenshots/
3. Commit the image files and the placeholder ![…](docs/screenshots/…) links above will resolve automatically.

• Row Level Security (RLS) on all Supabase tables
• Environment variables for sensitive data
• No private keys in frontend code
• Secure API routes with authentication

Contributions are welcome! Please read our contributing guidelines and submit PRs.

This project is licensed under the MIT License - see the LICENSE file for details.

• Solana Foundation
• Metaplex
• Jupiter
• All the amazing DeFi protocols integrated
• The Web3 community

• GitHub Issues: Report bugs
• Documentation: Wiki
• Community: Discord

• Additional DeFi protocol integrations
• More AI agent capabilities
• Enhanced mobile features
• Desktop app auto-updates
• Multi-chain support
• Advanced analytics dashboard

Built with 💜 by SMSDAO for the Solana ecosystem.