Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Where Solana Meets Intelligence
CYNE AI is your gateway to intelligent, AI-driven interactions with the Solana blockchain ecosystem. From real-time market analysis to advanced portfolio management, ELYX provides everything you need to streamline and enhance your blockchain journey.
CYNE AI is designed to empower users with intelligent agents capable of:
Automated DeFi Operations
Execute complex trading strategies.
Optimize liquidity provision and yield farming.
Enhance automated portfolio management.
Asset Management
Intelligent portfolio rebalancing.
Risk assessment based on real-time on-chain data.
Market Analytics
Perform real-time data analysis using Solana's on-chain metrics.
Identify emerging trends and market opportunities.
Smart Contract Interactions
Seamlessly engage with DeFi protocols.
Automate governance participation and protocol interactions.
Decentralized Architecture
Native Solana program integration ensures maximum compatibility.
Operates in a trustless execution environment with verifiable state transitions.
Supports Cross-Program Invocation (CPI) for complex interactions.
AI Implementation
Powered by Advanced Large Language Models with enhanced reasoning.
Zero-hallucination guarantees through constrained output frameworks.
Reinforcement Learning with Human Feedback (RLHF) ensures decision-making accuracy.
Integration of dynamic knowledge graphs for continuous learning.
Agent Autonomy
Self-improving decision frameworks for efficient operation.
Multi-step reasoning capabilities to handle complex tasks.
Fully programmable constraint systems.
Real-time market adaptation for dynamic strategies.
Sovereign Intelligence
Agents maintain true ownership, secured by blockchain technology, ensuring decentralized autonomy.
Verifiable Operations
All actions performed by agents are recorded on-chain with cryptographic proof, guaranteeing transparency and trust.
Protocol Integration
Deep integration with Solana's DeFi ecosystem, enabling seamless interactions across protocols.
Advanced Risk Management
Multi-layered security protocols and failsafe mechanisms provide institutional-grade reliability and protection.
CYNE AI represents a sophisticated fusion of DeFi automation and artificial intelligence, offering institutional-grade tools for complex on-chain operations while ensuring the security and verifiability inherent to blockchain systems.
Join us in revolutionizing the way you interact with DeFi. Let CYNE AI empower your journey in the Solana ecosystem! 🚀
$CYNE is the native utility token of the CYNE AI project, designed to create a sustainable ecosystem that rewards users and aligns incentives across the platform.
95% Circulating Supply: Community-driven and widely distributed to ensure decentralization and active engagement.
5% Developer Fund: Reserved to support development, infrastructure growth, and incentivizing contributors.
The majority of tokens will be released at launch to establish a decentralized ecosystem. This inclusive distribution strategy ensures broad participation, fostering equal opportunities for all community members to contribute to and benefit from the CYNE platform.
Key Goals:
Empower community ownership.
Drive decentralized decision-making.
Encourage active platform engagement.
This allocation supports the continued growth and sustainability of the CYNE ecosystem. The Developer Fund will focus on:
Open-Source Contributions: Encouraging community developers to enhance the platform.
Grants and Bounties: Rewarding innovative solutions and technical achievements.
Ecosystem Development: Strengthening the platform’s infrastructure and tools.
Community Initiatives: Supporting education, engagement, and growth programs.
Vesting Schedule:
The Developer Fund will be released over a 12-month period.
Equal portions will be unlocked monthly to maintain transparency and accountability.
Transparency Measures:
Publicly Verifiable Transactions: All fund movements will be available for public review.
Recipient Details: Information on grants, bounties, and expenditures will be regularly shared with the community.
CYNE prioritizes trust and openness. All token-related activities, including allocation, distribution, and burning, will be fully documented and accessible via:
Transaction Records
Escrow Details
Community Updates
By adhering to these principles, CYNE aims to establish a fair, transparent, and inclusive token economy that supports long-term growth and decentralization.
The CYNE AI repository will be made publicly accessible at the end of Q1. Once it's available, follow these steps to set up your development environment
The Cyne AI repository will be made publicly accessible by the end of Q1. Once available, follow these steps to set up your development environment:
Clone the Repository
Enter the Directory
Switch to the Latest Tagged Release
Install Dependencies
By default, the pnpm lockfile will not be updated during installations due to .npmrc settings (frozen-lockfile=true). To update the lockfile:
Use this command only when initializing the repository, bumping package versions, or adding new packages.
Copy the Example Environment File
Edit .env and Add Your Values
Example variables to configure:
Cyne AI supports multiple AI model configurations:
OpenAI:
Set the model in .env:
Custom Models:
Create a Character File
Navigate to the characters directory.
Use the provided default.character.json as a template to customize your agent's personality and functionality.
Example paths:
Open your browser to:
Begin interacting with your agent.
Create a bot in the Discord Developer Portal.
Add the bot to your server using the OAuth2 URL generator.
Add these values to .env:
Magic Eden Integrate with the Magic Eden NFT marketplace:
Jupiter DEX Aggregator For seamless token swaps and DeFi operations:
If you have an NVIDIA GPU, follow these steps:
Install CUDA Support:
Ensure that CUDA Toolkit, cuDNN, and cuBLAS are installed.
Start the Chat Interface
Run Multiple Agents
Node.js Version
Ensure Node.js 23+ is installed.
Check your version:
Sharp Installation Errors
🤖 Create Your First Agent
📝 Customize Agent Personalities
⚡ Add Advanced Features
For detailed guides, troubleshooting, and more, visit our Full Documentation. Join our Discord Community for support and updates!
Agents are the foundational elements of the CYNE AI framework, enabling seamless, intelligent, and autonomous interactions within the Solana ecosystem.
Example: State Methods
Compose Initial State:
Update State:
Best Practices:
agent.json file.Run Multiple Agents
Install with:
CUDA Setup Issues
Verify your GPU compatibility with the CUDA Toolkit.
composeState to initialize new states.Update states dynamically during interactions with updateRecentMessageState.
Cache frequently accessed data to enhance performance.
Memory systems provide agents with contextual understanding and continuity.
Types of Memory:
Message History: Tracks past interactions for conversational continuity.
Factual Memory: Stores specific details like wallet activity or token preferences.
Knowledge Base: Retains general knowledge about Solana, DeFi, and NFTs.
Relationship Tracking: Builds rapport by storing user-agent interaction history.
Memory Managers:
CYNE AI provides specialized memory managers:
messageManager: Tracks conversation history.
descriptionManager: Stores user profiles and descriptions.
loreManager: Retains agent knowledge and backstory.
Example: Memory Management
The evaluate method processes input, evaluates responses, and determines actionable outcomes.
Example: Evaluation
Use Randomized Memory: For more dynamic agent responses.
Optimize Memory Usage: Clean old data periodically to avoid performance bottlenecks.
Handle Errors Gracefully: Log errors to maintain stability.
Follow Immutability Principles: For state management to ensure reliability.
Actions Documentation: Learn how to configure and extend agent actions.
Evaluators Documentation: Dive into evaluation and goal-setting for agents.
Providers Documentation: Connect agents to external platforms and tools.
Full API Reference: Explore the full technical details of CYNE AI.
Start building intelligent agents with CYNE AI today!
pnpm start --characters="characters/whale_tracker.character.json,characters/staking_agent.character.json"pnpm install --include=optional sharpgit clone https://github.com/cyne-app/cynecd cynegit checkout $(git describe --tags --abbrev=0)pnpm install --no-frozen-lockfilepnpm install --no-frozen-lockfilepnpm buildcp .env.example .envDISCORD_APPLICATION_ID= # For Discord integration
DISCORD_API_TOKEN= # Bot token
OPENAI_API_KEY= # OpenAI API key
SOLANA_RPC_URL= # RPC endpoint for Solana
MAGICEDEN_API_KEY= # API key for NFT marketplace access
JUPITER_API_KEY= # Jupiter integration for DEX aggregatorCYNE_MODEL=gpt-4o
OR
CYNE_MODEL=gpt-4 characters/whale_tracker.character.json
characters/risk_manager.character.jsonhttp://localhost:5173/DISCORD_API_TOKEN=your_discord_bot_token
DISCORD_APPLICATION_ID=your_discord_application_idMAGICEDEN_API_KEY=your_api_keyJUPITER_API_KEY=your_api_keynpx --no node-llama-cpp source download --gpu cudapnpm startpnpm start --characters="characters/whale_tracker.character.json,characters/liquidity_manager.character.json"node -vpnpm start --character="characters/whale_tracker.character.json"const state = await runtime.composeState(message, {
additionalContext: "custom blockchain context",
});const updatedState = await runtime.updateRecentMessageState(state);const memoryManager = runtime.getMemoryManager("messages");
// Store memory
await memoryManager.createMemory({
id: messageId,
content: { text: "Analyzed a 1M SOL whale transaction" },
userId: "user123",
roomId: "room123",
});const evaluationResults = await runtime.evaluate(message, state, didRespond);What is CYNE AI?
CYNE AI is an open-source, multi-agent framework designed to create and manage intelligent AI agents that seamlessly interact with the Solana blockchain. These agents can perform tasks across decentralized finance (DeFi), NFTs, staking, liquidity management, and more. CYNE empowers users to access blockchain technology through intuitive AI-driven interfaces.
Who is behind CYNE AI?
CYNE AI is developed by a team of passionate blockchain and AI enthusiasts committed to advancing decentralized technology. The project will be open-source in the end od Q1 with its code available on GitHub for transparency and collaboration.
To start building with CYNE AI, follow these steps:
Install Prerequisites: Ensure Node.js (v23+) and pnpm (v9+) are installed.
Set Up Environment: Create a .env file with API keys, Solana RPC endpoints, and platform-specific tokens.
Install CYNE: Run the command:
Configure Connections
CYNE AI consists of the following core components:
Agents: Intelligent AI entities that interact with users and execute tasks on the Solana blockchain.
Actions: Predefined functions for tasks like token analysis, swaps, or liquidity management.
Clients: Connectors for platforms like Solana wallets, Magic Eden, and Jupiter DEX.
Plugins: Modular extensions to add custom actions, blockchain integrations, and new functionalities.
CYNE AI welcomes contributions from both technical and non-technical contributors:
Technical Contributions
Develop new actions, plugins, and clients to enhance functionality.
Optimize memory management and blockchain interactions.
Improve Solana integration and support DeFi tools like staking and liquidity management.
Expand AI capabilities, such as risk evaluation and sentiment tracking.
Non-Technical Contributions
Community Management: Help onboard users, moderate discussions, and promote awareness.
Content Creation: Write tutorials, create videos, and design visuals to showcase CYNE's capabilities.
Translation: Translate documentation to make CYNE globally accessible.
Feedback: Share insights to improve the platform and user experience.
CYNE AI is continuously evolving, with goals to:
Expand Platform Support: Add integrations with more Solana dApps and DeFi protocols.
Enhance AI Models: Incorporate advanced capabilities for blockchain automation and analytics.
Strengthen Security: Develop tools for liquidity analysis, rug pull detection, and trust scoring.
Grow the Community: Reward contributors and foster collaboration within the ecosystem.
What is $CYNE?
$CYNE is the native utility token for the ELYX ecosystem, enabling governance, rewards, and incentivization. It plays a central role in staking, liquidity provisioning, and community-driven initiatives.
How can I earn or use $CYNE tokens?
Stake $CYNE tokens to earn rewards.
Contribute to the ecosystem through development or community engagement.
Use $CYNE for governance votes and to access exclusive ecosystem features.
Will CYNE AI agents trade tokens?
Yes, CYNE AI agents can analyze and execute token trades. These trades are governed by user-defined parameters and the AI’s analysis of market conditions.
Can CYNE AI evaluate my project?
Absolutely! CYNE AI agents can use tools like the Rug Checker, Risk Analyzer, and Sentiment Analyzer to assess projects and provide actionable insights.
Who controls the $CYNE token?
$CYNE is governed by the community through decentralized decision-making. All governance and token-related actions are determined via community voting.
Join the Community: Engage in discussions and share your insights.
Contribute to Development: Help improve the framework or create new tools.
Spread the Word: Share CYNE AI with your network to grow the ecosystem.
For more information, visit the GitHub Repository or join the CYNE AI Discord Community for support and updates.
A character file in CYNE AI defines the behavior, configuration, and operational guidelines for AI agents.
Example:
postExamples
Social media-style content reflecting the character’s persona.
Example:
style
Defines the tone and communication guidelines for interactions.
Example:
topics
Highlights the character’s areas of expertise.
Define Your Agent: Use the provided JSON format to specify your agent’s personality, behavior, and knowledge.
Run Locally: Start the CYNE framework and interact with your customized AI agent.
Providers: External data sources for market analytics, user interactions, and wallet information.
Evaluators: Analyze blockchain data for informed decision-making, including tools for risk and sentiment analysis.
Character Files: JSON files that define an agent’s personality, skills, and operational parameters.
Memory System: A robust memory manager for storing contextual data on users, projects, and trends.
Example:
adjectives
Describes the character’s personality traits.
Example:
Randomization for Dynamic Responses
Break bios, lore, and posts into smaller sections to create variety in responses.
Knowledge Management
Regularly update the knowledge field to stay aligned with evolving Solana and blockchain trends.
Clear Style Guidelines
Define the character's tone and behavior for different communication contexts (e.g., chat, posts).
Diverse Examples
Provide varied scenarios to showcase the character's flexibility in interactions.
Agents Documentation: Learn how to configure and deploy agents.
Client Integration: Connect CYNE agents to platforms like Discord, Telegram, and Solana dApps.
Model Providers: Explore supported AI models for building agents.
For additional guidance, visit the CYNE AI Documentation Hub or join the CYNE AI Community for support and collaboration.
pnpm install @cyne_ai/core"messageExamples": [
[
{ "user": "user1", "content": { "text": "What is a rug pull?" } },
{ "user": "rug_checker", "content": { "text": "A rug pull is when project developers drain liquidity, causing significant losses for investors." } }
]
]"postExamples": [
"🚨 Whale Alert: 1M SOL just moved to a private wallet. Stay cautious!",
"Market activity is heating up—watch out for major liquidity changes."
]"style": {
"all": ["Maintain a professional tone", "Be concise and precise"],
"chat": ["Engage with clarity", "Ask clarifying questions when needed"],
"post": ["Focus on actionable insights", "Use impactful statements"]
}"topics": [
"DeFi",
"Whale Tracking",
"Liquidity Management"
]"adjectives": [
"trustworthy",
"analytical",
"knowledgeable"
]This guide provides best practices for managing secrets, API keys, and sensitive configurations within Cyne AI to ensure security and operational efficiency.
Cyne AI uses a hierarchical system for environment variables:
Character-specific secrets (highest priority).
Environment variables defined in .env files.
Default values (lowest priority).
Common secrets managed in Cyne AI:
Create a .env file from the provided template:
Configure environment variable discovery in your code:
Define secrets directly in character files for modular configuration:
Access secrets in your code:
Handle Solana wallet credentials securely:
Encrypt sensitive secrets before storage:
Use separate .env files for different environments:
.env.development – Development settings
.env.staging – Staging environment
.env.production – Production environment
Ensure required secrets are defined:
Exclude sensitive files from version control by adding the following to .gitignore:
Regularly rotate secrets to enhance security:
Missing Secrets Ensure required environment variables or character-specific secrets are defined:
Invalid Secret Format Validate the format of critical secrets like API keys:
Secret Loading Errors Handle errors gracefully during secret loading:
Use strong validation logic for keys.
Rotate keys periodically to reduce risks.
Restrict access to sensitive secrets using a controlled list.
Log unauthorized access attempts for monitoring.
Encrypt all sensitive data stored on disk.
Use AES-256-GCM encryption for strong security.
Configuration Guide: General setup instructions.
Local Development Guide: Best practices for local environments.
Infrastructure Guide: Secure deployment practices.
By following these guidelines, you can manage secrets effectively and securely within the Cyne AI framework, ensuring robust and secure operations.
Providers are essential components within the CYNE AI framework, enabling agents to access real-time blockchain data, contextual information, and other external data sources.
In CYNE AI, Providers are designed to:
Supply real-time data and contextual insights.
Integrate seamlessly with the AgentRuntime framework.
Format information for conversational templates, actions, and evaluations.
Ensure consistent access to Solana blockchain and other decentralized data.
A Provider in CYNE AI adheres to the following interface structure:
Providers interact with the agent runtime, message memory, and optional agent state to fetch and process relevant data for users.
1. Time Provider
The Time Provider adds temporal context to interactions, ensuring time-sensitive blockchain operations and market trends are accurately conveyed.
2. Market Data Provider
The Market Data Provider retrieves real-time token prices, trading volumes, and liquidity statistics from decentralized exchanges.
3. Wallet Insights Provider
The Wallet Insights Provider allows users to monitor their wallet balances and transaction histories.
4. Risk Analysis Provider
The Risk Analysis Provider evaluates potential risks in smart contracts, liquidity pools, or token investments.
5. Whale Tracking Provider
The Whale Tracking Provider monitors large transactions or whale activities on the Solana blockchain, alerting users to significant market movements.
Accessing Providers in Runtime
Providers can be utilized during state composition:
This example demonstrates integrating multiple data sources into a single provider for a holistic response:
Stale Data
Implement cache invalidation for outdated data:
Rate Limiting
Use exponential backoff for retries:
API Failures
Fallback to secondary data sources when primary APIs fail.
Agent Runtime Documentation
Memory System Documentation
Custom Actions Documentation
With CYNE AI, providers bring the power of real-time data and blockchain insights to intelligent, autonomous agents. Start creating your own providers today!
# API Keys
OPENAI_API_KEY=sk-your-openai-key
# Client Authentication
DISCORD_API_TOKEN=your-discord-token
TELEGRAM_BOT_TOKEN=your-telegram-token
# Solana Wallet Credentials
SOLANA_PRIVATE_KEY=example-private-key
SOLANA_PUBLIC_KEY=example-public-keycp .env.example .envimport { config } from "dotenv";
config(); // Load environment variables{
"name": "TradingAgent",
"settings": {
"secrets": {
"OPENAI_API_KEY": "character-specific-key",
"SOLANA_PRIVATE_KEY": "character-specific-wallet"
}
}
}const apiKey = runtime.getSetting("OPENAI_API_KEY");class WalletManager {
private async initializeWallet(runtime: IAgentRuntime) {
const privateKey = runtime.getSetting("SOLANA_PRIVATE_KEY");
if (!privateKey) {
throw new Error("Wallet private key not configured");
}
// Validate and initialize the wallet
const keyBuffer = Buffer.from(privateKey, "base64");
if (keyBuffer.length !== 64) {
throw new Error("Invalid key format");
}
return new Wallet(privateKey);
}
}import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
class SecretEncryption {
static async encrypt(value: string, key: Buffer): Promise<string> {
const iv = randomBytes(16);
const cipher = createCipheriv("aes-256-gcm", key, iv);
let encrypted = cipher.update(value, "utf8", "hex");
encrypted += cipher.final("hex");
return JSON.stringify({
iv: iv.toString("hex"),
encrypted,
tag: cipher.getAuthTag().toString("hex")
});
}
static async decrypt(encrypted: string, key: Buffer): Promise<string> {
const { iv, encrypted: encryptedData, tag } = JSON.parse(encrypted);
const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(iv, "hex"));
decipher.setAuthTag(Buffer.from(tag, "hex"));
let decrypted = decipher.update(encryptedData, "hex", "utf8");
decrypted += decipher.final("utf8");
return decrypted;
}
}async function validateSecrets(character: Character): Promise<void> {
const required = ["OPENAI_API_KEY", "SOLANA_PRIVATE_KEY"];
const missing = required.filter((key) => !character.settings.secrets[key]);
if (missing.length > 0) {
throw new Error(`Missing required secrets: ${missing.join(", ")}`);
}
}.env
characters/**/secrets.jsonclass SecretRotation {
private static readonly SECRET_LIFETIME = 90 * 24 * 60 * 60 * 1000; // 90 days
async shouldRotateSecret(secretName: string): Promise<boolean> {
const lastRotation = await this.getLastRotation(secretName);
return Date.now() - lastRotation > SecretRotation.SECRET_LIFETIME;
}
async rotateSecret(secretName: string): Promise<void> {
// Logic for secret rotation
const newSecret = await this.generateNewSecret();
await this.updateSecret(secretName, newSecret);
}
}if (!process.env.OPENAI_API_KEY) {
throw new Error("OpenAI API key is missing.");
}function validateApiKey(key: string): boolean {
return key.startsWith("sk-") && key.length > 20;
}try {
await loadSecrets();
} catch (error) {
console.error("Error loading secrets:", error.message);
}interface Provider {
get: (
runtime: IAgentRuntime,
message: Memory,
state?: State
) => Promise<string>;
}const timeProvider: Provider = {
get: async (_runtime: IAgentRuntime, _message: Memory) => {
const currentDate = new Date();
const currentTime = currentDate.toLocaleTimeString("en-US");
const currentDateString = currentDate.toDateString();
return `Current date and time: ${currentDateString}, ${currentTime}`;
},
};const marketDataProvider: Provider = {
get: async (runtime: IAgentRuntime, message: Memory) => {
const token = message.content.text; // Extract token name or symbol
const marketData = await runtime.getMarketData(token); // Custom runtime function
return `The current price of ${token} is ${marketData.price} SOL with a trading volume of ${marketData.volume}.`;
},
};const walletInsightsProvider: Provider = {
get: async (runtime: IAgentRuntime, message: Memory, state?: State) => {
const walletAddress = state?.userWalletAddress || message.content.text;
const walletData = await runtime.getWalletData(walletAddress);
return `Wallet ${walletAddress} has a balance of ${walletData.balance} SOL and holds ${walletData.tokenHoldings.length} tokens.`;
},
};const riskAnalysisProvider: Provider = {
get: async (runtime: IAgentRuntime, message: Memory) => {
const contractAddress = message.content.text;
const riskScore = await runtime.analyzeRisk(contractAddress);
return `The contract at ${contractAddress} has a risk score of ${riskScore}, indicating ${riskScore > 70 ? "high risk" : "low risk"}.`;
},
};runtime.registerContextProvider(marketDataProvider);const state = await runtime.composeState(message);const comprehensiveProvider: Provider = {
get: async (runtime: IAgentRuntime, message: Memory, state?: State) => {
try {
const messages = await runtime.messageManager.getMemories({
roomId: message.roomId,
count: 5,
});
const walletData = await runtime.getWalletData(state?.userWalletAddress);
const facts = await runtime.messageManager.getMemories({
roomId: message.roomId,
tableName: "facts",
count: 3,
});
return `
# Recent Messages
${messages.map((m) => `- ${m.content.text}`).join("\n")}
# Wallet Information
Balance: ${walletData.balance} SOL
Tokens: ${walletData.tokenHoldings.length}
# Relevant Facts
${facts.map((f) => `- ${f.content.text}`).join("\n")}
`.trim();
} catch (error) {
console.error("Provider error:", error);
return "Unable to fetch context at the moment.";
}
},
};const invalidateCache = async (pattern: string) => {
const keys = await cache.keys(pattern);
await Promise.all(keys.map((key) => cache.del(key)));
};const backoff = async (attempt: number) => {
const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
await new Promise((resolve) => setTimeout(resolve, delay));
};This guide provides a comprehensive walkthrough on configuring Cyne AI for various use cases and environments.
Start by creating an environment configuration file:
These are the essential environment variables required to configure Cyne AI:
Character files define the personality, behavior, and capabilities of Cyne AI agents. These files are stored in the characters/ directory.
Example structure:
You can load character files during runtime:
To extend the agent's functionality, add custom actions:
Create a custom_actions/ directory.
Add your action files (e.g., myCustomAction.ts) to this directory.
Example custom action configuration:
To configure the Solana provider, update the environment variables:
You can register the Solana provider during runtime:
This provider retrieves real-time token prices and trading volumes.
Example:
Customize runtime behavior with the following settings:
Enable and configure plugins by defining them in the configuration file:
Use separate .env files for development, staging, and production.
Follow naming conventions: .env.development, .env.staging, .env.production.
Never commit sensitive keys or secrets to version control.
Use secret management tools for production environments.
Rotate API keys regularly.
Keep character files modular for easy customization.
Use inheritance or shared configuration files for common traits.
Enable only the necessary plugins to reduce resource usage.
Use separate configuration files for each plugin to isolate settings.
Use SQLite for development environments.
Configure connection pooling for production databases (e.g., PostgreSQL).
Optimize database performance with appropriate indexes.
Environment Variables Not Loading Verify the location and syntax of the .env file:
Character Loading Failures Validate the structure of the character file:
Database Connection Issues Test the database connection with the following script:
Use the built-in configuration validator:
This will validate:
Environment variables
Character files
Database configuration
Plugin settings
Quickstart Guide: Learn how to set up your first Cyne AI agent.
Secrets Management: Securely manage API keys and sensitive information.
Plugin Development: Build custom plugins to extend Cyne AI.
Local Development: Optimize your local environment for Cyne AI development.
By following this guide, you can configure Cyne AI to operate effectively in any environment, ensuring seamless interactions with the Solana blockchain ecosystem.
cp .env.example .env# Core API Keys
OPENAI_API_KEY=sk-your-openai-key # For AI functionality
CYNE_SERVER_URL= # Optional custom AI endpoint
# Solana Configuration
SOLANA_NETWORK=mainnet-beta # Solana network (e.g., devnet, mainnet-beta)
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com # Solana RPC endpoint{
"name": "AgentName",
"clients": ["telegram", "discord"],
"modelProvider": "openai",
"settings": {
"secrets": {
"OPENAI_API_KEY": "character-specific-key"
}
}
}# Load the default character
pnpm start
# Load a specific character
pnpm start --characters="characters/agent-name.json"
# Load multiple characters
pnpm start --characters="characters/agent1.json,characters/agent2.json"export const myCustomAction: Action = {
name: "CUSTOM_ACTION",
similes: ["ACTION_TRIGGER", "ALTERNATIVE_TRIGGER"],
validate: async (runtime: IAgentRuntime, message: Memory) => {
// Custom validation logic
return true;
},
description: "Description of the action's purpose.",
handler: async (runtime: IAgentRuntime, message: Memory) => {
// Action implementation logic
},
};SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
SOLANA_NETWORK=mainnet-betaruntime.registerContextProvider(solanaProvider);const marketDataProvider: Provider = {
get: async (runtime: IAgentRuntime, message: Memory) => {
const token = message.content.text; // Extract token name
const marketData = await runtime.getMarketData(token); // Fetch market data
return `The current price of ${token} is ${marketData.price} SOL.`;
},
};const settings = {
// Logging
DEBUG: "cyne:*",
LOG_LEVEL: "info",
// Performance
MAX_CONCURRENT_REQUESTS: 5,
REQUEST_TIMEOUT: 30000,
// Memory
MEMORY_TTL: 3600, // Time-to-live for memory entries (seconds)
MAX_MEMORY_ITEMS: 1000, // Maximum number of memory entries
};plugins:
- name: solana
enabled: true
settings:
network: mainnet-beta
endpoint: https://api.mainnet-beta.solana.comnode -e "console.log(require('path').resolve('.env'))"npx ajv validate -s character-schema.json -d characters/agent-name.jsonnpx ts-node scripts/test-db-connection.tspnpm run validate-configDynamic Tasks are the core building blocks of the Cyne AI framework, enabling agents to perform specific tasks such as whale tracking, liquidity management, token swapping, and more.
Each task in Cyne AI consists of the following key components:
name: A unique identifier for the action.
similes: Alternative names or triggers for the action.
description: A detailed explanation of the action's purpose.
validate: Logic to check whether the action can be executed based on the current context.
handler: The implementation of the action's behavior.
examples: Demonstrates how the action works in practice.
The structure of an action in Cyne AI follows the format below:
name: Unique name for the action.
similes: Triggers or alternative names that activate the action.
description: A clear and concise explanation of the action's functionality.
validate: Ensures the action can be executed under the current conditions.
Continues the conversation by gathering more context or expanding on a topic.
Disengages gracefully from conversations when the discussion is finished or irrelevant.
Monitors large transactions on Solana and alerts users to potential market impacts.
Facilitates token swaps using the DEX aggregator for optimal rates.
Performs risk analysis on a smart contract or liquidity pool.
Creates detailed performance or trend reports.
Clear Purpose: Define a single, well-focused purpose for each action.
Robust Validation: Check prerequisites and validate inputs.
Error Handling: Handle errors gracefully and provide meaningful feedback.
Comprehensive Documentation: Provide examples and explain expected inputs, outputs, and scenarios.
handler: Defines the logic and operations executed by the action.
examples: Provides real-world usage examples.
suppressInitialMessage: Suppresses automatic responses if the action generates its own output.
Perform token swaps or transactions:
Handle PDF document analysis and text extraction:
Manage agent memory efficiently for contextual understanding:
Custom plugins can extend Cyne AI’s functionality:
Actions can execute advanced workflows and interactions:
Configure runtime behavior to meet specific requirements:
Optimize AI model parameters for better performance:
Implement caching to improve system performance:
Manage task execution efficiently using a queue system:
Ensure robust error handling and logging:
Implement resource acquisition and cleanup:
Memory Leaks
Monitor memory usage.
Clean up unused memory allocations.
Performance Bottlenecks
Profile slow operations.
Use batching and caching.
Integration Issues
Verify API credentials and network connectivity.
Validate request formatting.
Enable debug logs for detailed traceability:
Infrastructure Guide: Deployment best practices for Cyne AI.
Advanced Actions: Detailed documentation for creating custom actions.
Plugin Development: Guide to building custom plugins for Cyne AI.
Model Optimization: Fine-tuning AI models for specific use cases.
This guide equips you to leverage the full capabilities of Cyne AI to create powerful, customized, and efficient blockchain agents. Let me know if additional details are required!
interface Action {
name: string;
similes: string[];
description: string;
validate: (runtime: IAgentRuntime, message: Memory) => Promise<boolean>;
handler: (
runtime: IAgentRuntime,
message: Memory,
state?: State
) => Promise<void>;
examples: ActionExample[][];
suppressInitialMessage?: boolean;
}const continueAction: Action = {
name: "CONTINUE",
similes: ["ELABORATE", "KEEP_TALKING"],
description: "Expands on a topic or gathers additional context.",
validate: async () => true,
handler: async (runtime, message, state) => {
// Logic to continue the conversation
},
};const ignoreAction: Action = {
name: "IGNORE",
similes: ["STOP_TALKING", "END_CONVERSATION"],
description: "Stops responding when the conversation is no longer relevant.",
handler: async () => true,
};const trackWhaleAction: Action = {
name: "TRACK_WHALE",
similes: ["MONITOR_WHALE", "DETECT_WHALE"],
description: "Tracks large token transactions in real time.",
validate: async (runtime, message) => {
const content = (message.content as Content).text;
return /track whale/i.test(content);
},
handler: async (runtime, message, state) => {
const whaleData = await runtime.getWhaleActivity();
return `Whale Alert: ${whaleData.amount} SOL moved to Pool ${whaleData.pool}.`;
},
};const executeSwapAction: Action = {
name: "EXECUTE_SWAP",
similes: ["SWAP_TOKENS", "TRADE"],
description: "Performs token swaps with the best available rates on the DEX aggregator.",
validate: async (runtime, message) => {
const content = (message.content as Content).text;
return /\bswap\b/i.test(content) && content.includes("to");
},
handler: async (runtime, message, state) => {
const [fromToken, toToken] = message.content.text.split("to").map((t) => t.trim());
const swapResult = await runtime.dexAggregator.swap(fromToken, toToken);
return `Swapped ${swapResult.amount} ${fromToken} to ${swapResult.amount} ${toToken} at the best rate.`;
},
};const analyzeRiskAction: Action = {
name: "ANALYZE_RISK",
similes: ["RISK_ANALYSIS", "CHECK_RISK"],
description: "Evaluates the risk level of a given contract or liquidity pool.",
validate: async (runtime, message) => {
const address = (message.content as Content).text;
return /0x[a-fA-F0-9]{40}/.test(address); // Validates Ethereum-style contract address
},
handler: async (runtime, message) => {
const riskScore = await runtime.riskAnalyzer.analyze(message.content.text);
return `Risk Analysis: The contract has a risk score of ${riskScore}. ${riskScore > 70 ? "High Risk!" : "Low Risk."}`;
},
};const generateReportAction: Action = {
name: "GENERATE_REPORT",
similes: ["CREATE_REPORT", "PORTFOLIO_REPORT"],
description: "Generates a comprehensive report of portfolio performance or market trends.",
validate: async (runtime, message) => {
const text = (message.content as Content).text;
return /generate report/i.test(text);
},
handler: async (runtime, message) => {
const reportData = await runtime.generatePortfolioReport();
return `Portfolio Report: ${reportData.summary}`;
},
};const customAction: Action = {
name: "CUSTOM_ACTION",
similes: ["ALTERNATIVE_TRIGGER"],
description: "Defines the purpose of this action.",
validate: async (runtime, message) => {
// Custom validation logic
return true;
},
handler: async (runtime, message, state) => {
// Custom action logic
},
examples: [
[
{
user: "{{user1}}",
content: { text: "Trigger message" },
},
{
user: "{{user2}}",
content: { text: "Response", action: "CUSTOM_ACTION" },
},
],
],
};import { solanaPlugin } from "@cyneai/core/plugin-solana";
// Register Solana plugin
runtime.registerPlugin(solanaPlugin);// Swap tokens
const swapResult = await swapToken(
connection,
walletPublicKey,
inputTokenCA,
outputTokenCA,
amount,
);
// Sell tokens
const sellResult = await sellToken({
sdk,
seller: walletKeypair,
mint: tokenMint,
amount: sellAmount,
slippage: "1",
connection,
});class PdfService extends Service {
async convertPdfToText(pdfBuffer: Buffer): Promise<string> {
const pdf = await getDocument({ data: pdfBuffer }).promise;
const numPages = pdf.numPages;
const textPages = [];
for (let pageNum = 1; pageNum <= numPages; pageNum++) {
const page = await pdf.getPage(pageNum);
const textContent = await page.getTextContent();
const pageText = textContent.items
.map((item) => item.str)
.join(" ");
textPages.push(pageText);
}
return textPages.join("\n");
}
}class MemoryManager {
async getMemories({
agentId,
roomId,
count,
}: {
agentId: string;
roomId: string;
count: number;
}): Promise<Memory[]> {
// Implement memory retrieval logic
}
async createMemory(memory: Memory): Promise<void> {
// Store memory data
}
}const customPlugin: Plugin = {
name: "custom-plugin",
description: "A custom plugin for Cyne AI",
actions: [
// Define custom actions here
],
providers: [
// Add custom providers here
],
};export const complexAction: Action = {
name: "COMPLEX_ACTION",
similes: ["ALTERNATIVE_NAME", "OTHER_NAME"],
validate: async (runtime: IAgentRuntime, message: Memory) => {
// Validate action execution conditions
return true;
},
handler: async (runtime, message, state, options) => {
// Define complex action logic
return true;
},
};const customRuntime = new AgentRuntime({
databaseAdapter: new PostgresDatabaseAdapter(config),
modelProvider: new OpenAIProvider(apiKey),
plugins: [solanaPlugin],
});const modelConfig = {
modelClass: ModelClass.LARGE,
temperature: 0.7,
maxTokens: 2000,
topP: 0.9,
frequencyPenalty: 0.5,
presencePenalty: 0.5,
};
const response = await generateText({
runtime,
context: prompt,
...modelConfig,
});class CacheManager {
private cache: NodeCache;
constructor() {
this.cache = new NodeCache({ stdTTL: 300 });
}
async getCachedData<T>(key: string): Promise<T | null> {
// Implement caching logic
}
}class QueueManager {
private queue: string[] = [];
private processing: boolean = false;
async processQueue(): Promise<void> {
if (this.processing || this.queue.length === 0) return;
this.processing = true;
while (this.queue.length > 0) {
const item = this.queue.shift();
await this.processItem(item);
}
this.processing = false;
}
}try {
const result = await performOperation();
if (!result) throw new Error("Operation failed");
} catch (error) {
console.error("Error during operation:", error);
}class ResourceManager {
private resources: Map<string, Resource> = new Map();
async acquire(id: string): Promise<Resource> {
// Acquire resource logic
}
async release(id: string): Promise<void> {
// Release resource logic
}
}const debug = require("debug")("cyne:advanced");
debug("Operation details: %O", {
operation: "complexOperation",
parameters: params,
result: result,
});Node.js 23+
pnpm
Git
VS Code for development
Docker for database management
CUDA Toolkit for GPU acceleration
Clone the Cyne AI repository and install dependencies:
Set up your development environment:
Update essential variables in .env:
For local inference without external APIs:
Start the development server with specific characters or configurations:
pnpm run build: Build the project.
pnpm run clean: Clean build artifacts.
pnpm run dev: Start the development server.
pnpm run test: Run all tests.
pnpm run lint: Lint the codebase.
For development, use SQLite:
Use an in-memory database for testing:
Use the provided utilities for testing:
Plugins can extend Cyne AI’s capabilities:
Set up a debug configuration for Cyne AI:
This guide ensures that your Cyne AI development environment is set up efficiently and provides the tools needed for productive local development. Let me know if you need additional sections or customization!
# Clone the repository
git clone https://github.com/cyne-ai/cyne
cd cyne
# Install dependencies
pnpm installcp .env.example .envOPENAI_API_KEY=sk-your-openai-key # Optional for OpenAI integration
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com # Solana RPC endpoint
SOLANA_NETWORK=mainnet-beta # Solana network# Install CUDA support for NVIDIA GPUs
npx --no node-llama-cpp source download --gpu cuda
# Models will download automatically from Hugging Face on the first run# Start with the default character
pnpm run dev
# Start with a specific character
pnpm run dev --characters="characters/my-character.json"
# Start with multiple characters
pnpm run dev --characters="characters/char1.json,characters/char2.json"import { SqliteDatabaseAdapter } from "@cyneai/core/adapters";
import Database from "better-sqlite3";
const db = new SqliteDatabaseAdapter(new Database("./dev.db"));import { SqlJsDatabaseAdapter } from "@cyneai/core/adapters";
const db = new SqlJsDatabaseAdapter(new Database(":memory:"));# Run all tests
pnpm run test
# Run tests with coverage
pnpm run test:coverageimport { runAiTest } from "@cyneai/core/test_resources";
describe("Feature Test", () => {
it("should respond correctly", async () => {
const result = await runAiTest({
messages: [{ user: "user1", content: { text: "test input" } }],
expected: "expected output",
});
expect(result.success).toBe(true);
});
});// plugins/my-plugin/src/index.ts
import { Plugin } from "@cyneai/core/types";
export const myPlugin: Plugin = {
name: "my-plugin",
description: "Custom plugin for Cyne AI",
actions: [],
providers: [],
};{
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "Debug Cyne AI",
"skipFiles": ["<node_internals>/**"],
"program": "${workspaceFolder}/src/index.ts",
"runtimeArgs": ["-r", "ts-node/register"],
"env": {
"DEBUG": "cyne:*"
}
}
]
}CYNE AI is an open-source project that integrates advanced AI models with blockchain technology, creating an intelligent interface for the Solana ecosystem.
At CYNE AI, our mission is to revolutionize blockchain interactions by building cutting-edge, open-source infrastructure powered by AI. We are committed to making blockchain technology more accessible, transparent, and user-friendly. Our key objectives include:
Developing Transparent Solutions: Delivering community-driven tools and solutions to foster trust and collaboration in the blockchain ecosystem.
Creating Intuitive Interfaces: Leveraging advanced AI models to simplify interactions with the Solana blockchain.
Fostering an Inclusive Ecosystem: Building a vibrant developer community where innovation thrives.
Driving Innovation: Pioneering the integration of AI and blockchain technology to unlock new possibilities.
Full-Stack Architecture: CYNE AI is built on a modern, scalable tech stack to ensure optimal performance and reliability.
Advanced AI Integration: Incorporating state-of-the-art language models like GPT-4 for unparalleled capabilities in blockchain interactions.
Robust Security: Prioritizing top-tier protection for user data and blockchain transactions, ensuring a safe and trusted environment.
Optimized Blockchain Operations
Natural Language Understanding: Empowering users to interact with the blockchain effortlessly through intuitive commands.
Real-Time Responses: Minimizing latency for a smooth and seamless user experience.
Cross-Platform Compatibility: Ensuring that CYNE AI is accessible on a variety of devices and platforms for maximum reach.
Comprehensive Error Handling: Delivering a reliable and user-friendly experience with clear feedback and guidance.
Open-Source Development: Maintaining transparency and inviting collaboration by keeping CYNE AI’s core open source.
Community-Driven Roadmap: Incorporating user feedback and insights to guide the development of new features and improvements.
Transparent Documentation: Providing clear, accessible, and regularly updated resources to support developers and users.
Active Contributions
At CYNE AI, we are building the future of blockchain interactions by combining the power of AI with the performance of Solana. Join us on this journey to redefine how users and developers interact with blockchain technology.
Welcome to CYNE AI! Our platform is packed with powerful tools and intelligent agents designed to simplify and enhance your experience within the Solana ecosystem.
Description: Explore tokens with the highest trading volume on Solana.
Key Features:
Highlights actively traded tokens.
Provides insights into liquidity and market interest.
Use Case: Find tokens with high demand for strategic trading.
🌐 What’s Trending on Solana?
Description: Stay updated on the latest market trends and insights.
Key Features:
Tracks tokens, projects, and social media activity.
Summarizes key market trends.
Building on the foundation, this phase introduces tools to empower your trading strategies.
🐋 Whale Tracker
Monitor large transactions in real-time to understand market movements.
⚠️ Rug Checker
Evaluate risks of potential rug pulls or malicious contracts to safeguard investments.
💭 Sentiment Analyzer
Analyze public sentiment around specific tokens and projects.
🔒 Risk Analyzer
Assess risks in liquidity pools, tokens, or DeFi protocols.
📊 Performance Reporter
Generate detailed reports on token performance and market trends.
📂 Portfolio Manager
Monitor and manage your wallet, track assets, and optimize your portfolio.
🌱 Staking Agent
Discover high-yield staking opportunities and manage strategies.
We believe in transparency and collaboration. At the end of Q1, we’ll make the CYNE AI source code public on GitHub!
GitHub Repository:
Explore CYNE AI’s inner workings.
Contribute to its growth through feedback, pull requests, and feature suggestions.
Join a collaborative blockchain intelligence ecosystem.
Enhanced User Experience: Gradual unlocks prevent feature overload and allow for focused exploration.
Platform Stability: Staggered releases ensure smooth performance and scalability.
Community Engagement: Keeps excitement alive as new features are introduced.
Looking ahead, we’re working on:
NFT Analytics: Comprehensive tools for analyzing NFT collections.
Customizable Agents: Tailor agents to meet specific user needs.
Advanced Integrations: Seamless connectivity with emerging Solana protocols.
Thank you for being part of the ELYX AI community! Together, we’re transforming blockchain intelligence. 🌟
Use Case: Discover what’s buzzing in the Solana ecosystem.