AI Module

The Cart.fun AI Module provides a framework for integrating AI capabilities into decentralized marketplaces on Solana. It supports features like product recommendations, natural language search, content generation, and sentiment analysis.

Overview

The AI Module enhances the Cart.fun ecosystem with intelligent features that improve user experience and help vendors increase sales. By leveraging state-of-the-art AI models and techniques, marketplaces can offer advanced shopping experiences comparable to leading centralized e-commerce platforms, but in a decentralized context.

This module is designed to be extensible, with a pluggable architecture that supports different AI model types and provider integrations. It can be configured at the marketplace level, allowing each marketplace to select which AI features they want to enable and how they should be tuned.

The AI Module relies on Rig AI for model inference and vector storage capabilities, making it easier to integrate with popular AI providers while maintaining a consistent interface.

Architecture

The AI Module consists of several components working together to provide AI capabilities to Cart.fun marketplaces.

Core Components

Name
AIConfig
Type
component
Description
Stores the marketplace-level AI configuration
Name
AIModel
Type
component
Description
Manages model-specific settings and API connections
Name
SearchIndex
Type
component
Description
Maintains vector embeddings for products in a marketplace
Name
RecommendationHistory
Type
component
Description
Tracks user interactions for personalized recommendations

Feature Support

The AI Module supports the following features:

Name
Basic Recommendations
Type
feature
Description
Product recommendations based on marketplace-wide popularity
Name
Advanced Recommendations
Type
feature
Description
Personalized product recommendations based on user history
Name
Natural Language Search
Type
feature
Description
Semantic search for products using natural language queries

Name
Content Generation
Type
feature
Description
AI-generated product descriptions and marketing content
Name
Sentiment Analysis
Type
feature
Description
Analysis of review sentiment for product feedback
Name
Personalization
Type
feature
Description
Tailored marketplace experiences for individual users

Integration Points

The AI Module integrates with the following Rig AI components:

Embedding Models - For generating vector representations of products
Vector Stores - For efficient similarity search of product embeddings
LLM Providers - For natural language processing tasks
Agent Framework - For complex AI workflows and reasoning

Account Structure

AIConfig

The AIConfig account stores marketplace-level AI configuration and feature flags:

pub struct AIConfig {
    pub authority: Pubkey,         // 32 bytes - Marketplace authority
    pub marketplace: Pubkey,       // 32 bytes - Reference to marketplace
    pub is_active: bool,           // 1 byte - Active status
    pub features_enabled: AIFeatures, // Variable - Enabled AI features
    pub default_model: String,     // Variable - Default AI model for marketplace
    pub api_config: APIConfig,     // Variable - API connection configuration
    pub recommendation_config: RecommendationConfig, // Variable - Recommendation settings
    pub search_config: SearchConfig, // Variable - Search settings
    pub bump: u8,                  // 1 byte - PDA bump seed
}

AIFeatures

The AIFeatures struct defines which AI capabilities are enabled for a marketplace:

pub struct AIFeatures {
    pub enable_recommendations: bool, // Product recommendation system
    pub enable_natural_language_search: bool, // Semantic search capability
    pub enable_content_generation: bool, // AI content generation
    pub enable_sentiment_analysis: bool, // Review sentiment analysis
    pub enable_personalization: bool, // User-specific experiences
}

SearchIndex

The SearchIndex account stores information about the vector embeddings for a marketplace:

pub struct SearchIndex {
    pub marketplace: Pubkey,       // 32 bytes - Reference to marketplace
    pub index_url: String,         // Variable - URL to vector index
    pub embedding_model: String,   // Variable - Model used for embeddings
    pub last_updated: i64,         // 8 bytes - Last index update timestamp
    pub total_products: u32,       // 4 bytes - Number of products in index
    pub bump: u8,                  // 1 byte - PDA bump seed
}

Key Features

Product Recommendations

The recommendation system utilizes collaborative filtering and content-based approaches to suggest products to users:

Name
marketplace_recommendations
Type
function
Description
Get popular products in a marketplace
Name
user_recommendations
Type
function
Description
Get personalized recommendations based on user history
Name
similar_products
Type
function
Description
Find products similar to a given product
Name
complementary_products
Type
function
Description
Find products that complement a given product

Natural Language Search

The search system uses vector embeddings to enable semantic searching of products:

Name
search_products
Type
function
Description
Search products using natural language queries
Name
filter_results
Type
function
Description
Apply filters to search results
Name
query_understanding
Type
function
Description
Extract intent and entities from user queries

Content Generation

AI-powered content generation helps vendors create better product listings:

Name
generate_description
Type
function
Description
Generate product descriptions from basic information
Name
improve_description
Type
function
Description
Enhance existing product descriptions
Name
generate_tags
Type
function
Description
Generate relevant tags for a product

Usage Examples

Setting Up AI Features for a Marketplace

import { Connection, Keypair } from '@solana/web3.js'
import { CartProtocol, NetworkType } from '@cartdotfun/sdk'

async function enableAIFeatures(marketplaceId) {
  const connection = new Connection(
    'https://api.devnet.solana.com',
    'confirmed',
  )
  const adminWallet = Keypair.fromSecretKey(/* your secret key */)

  const cartProtocol = new CartProtocol({
    connection,
    wallet: adminWallet,
    network: NetworkType.Devnet,
  })

  // Initialize AI configuration for a marketplace
  const { transaction } = await cartProtocol.ai.initializeAIConfig({
    marketplaceId,
    featuresEnabled: {
      enableRecommendations: true,
      enableNaturalLanguageSearch: true,
      enableContentGeneration: true,
      enableSentimentAnalysis: false,
      enablePersonalization: true,
    },
    defaultModel: 'gpt-4',
    apiConfig: {
      rigApiKey: 'your-rig-api-key',
      openaiApiKey: 'your-openai-api-key',
    },
    recommendationConfig: {
      recommendationCount: 5,
      includeViewedItems: false,
      includePurchasedItems: false,
    },
    searchConfig: {
      maxResults: 10,
      minScore: 0.7,
      includeMetadata: true,
    },
  })

  const signature = await cartProtocol.sendAndConfirmTransaction(transaction)
  console.log('AI features enabled:', signature)
}

Using Natural Language Search

async function searchProducts(marketplaceId, query) {
  // Assuming cartProtocol is already initialized

  // Search for products using natural language
  const searchResults = await cartProtocol.ai.searchProducts({
    marketplaceId,
    query,
    maxResults: 10,
    filter: {
      minPrice: 0.1 * 1e9, // 0.1 SOL in lamports
      maxPrice: 2 * 1e9, // 2 SOL in lamports
      categories: ['art', 'collectibles'],
    },
  })

  console.log(`Found ${searchResults.length} results for: "${query}"`)

  searchResults.forEach((product, index) => {
    console.log(`${index + 1}. ${product.name} - ${product.price / 1e9} SOL`)
    console.log(`   Match score: ${product.score}`)
    console.log(`   ${product.description.substring(0, 100)}...`)
  })

  return searchResults
}

Generating Product Descriptions

async function generateProductDescription(productInfo) {
  // Assuming cartProtocol is already initialized

  const generatedContent = await cartProtocol.ai.generateDescription({
    productName: productInfo.name,
    productType: productInfo.type,
    keyFeatures: productInfo.features,
    targetAudience: productInfo.audience,
    tone: 'professional',
    length: 'medium',
  })

  console.log('Generated Description:')
  console.log(generatedContent.description)
  console.log('\nSuggested Tags:')
  console.log(generatedContent.tags.join(', '))

  return generatedContent
}

For more detailed information about the AI Module, refer to these resources: