Data Connectors

Providers are essential components within the CYNE AI framework, enabling agents to access real-time blockchain data, contextual information, and other external data sources.

Overview

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.

Core Structure

A Provider in CYNE AI adheres to the following interface structure:

interface Provider {
    get: (
        runtime: IAgentRuntime,
        message: Memory,
        state?: State
    ) => Promise<string>;
}

Providers interact with the agent runtime, message memory, and optional agent state to fetch and process relevant data for users.

Built-in Providers in CYNE AI

1. Time Provider

The Time Provider adds temporal context to interactions, ensuring time-sensitive blockchain operations and market trends are accurately conveyed.

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}`;
    },
};

2. Market Data Provider

The Market Data Provider retrieves real-time token prices, trading volumes, and liquidity statistics from decentralized exchanges.

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}.`;
    },
};

3. Wallet Insights Provider

The Wallet Insights Provider allows users to monitor their wallet balances and transaction histories.

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.`;
    },
};

4. Risk Analysis Provider

The Risk Analysis Provider evaluates potential risks in smart contracts, liquidity pools, or token investments.

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"}.`;
    },
};

5. Whale Tracking Provider

The Whale Tracking Provider monitors large transactions or whale activities on the Solana blockchain, alerting users to significant market movements.

runtime.registerContextProvider(marketDataProvider);

Accessing Providers in Runtime

Providers can be utilized during state composition:

const state = await runtime.composeState(message);

Comprehensive Provider Example

This example demonstrates integrating multiple data sources into a single provider for a holistic response:

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.";
        }
    },
};

Troubleshooting

Stale Data

Implement cache invalidation for outdated data:

const invalidateCache = async (pattern: string) => {
    const keys = await cache.keys(pattern);
    await Promise.all(keys.map((key) => cache.del(key)));
};

Rate Limiting

Use exponential backoff for retries:

const backoff = async (attempt: number) => {
    const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
    await new Promise((resolve) => setTimeout(resolve, delay));
};

API Failures

Fallback to secondary data sources when primary APIs fail.