📜AI721

Make NFT's AI personality indexable and verifiable on the blockchain.

Introduction

What is AI721

AI721 introduces a standard that extends the AI capabilities of ERC721. It's used to index and describe the AI personality of an NFT, and verify if a specific AI personality belongs to a particular NFT.

AI721 will not make any break changes on ERC721. It can be merged with ERC721, or deployed as an independent contract and associated with an existing ERC721 contract.

Why we need AI721

LLMs enable everyone to create AI personalities with any prompts. You can create any kinds of characters with different personalities with some tools like character.ai. However, it's centralized, non-transparent, and unable to achieve consensus.

If we want to describe NFT's AI personalities on chain and access it without relying on any centralized 3rd parties, we need to define a standard to implement this process, ensuring that anyone can obtain the same AI personality through the same protocol.

AI721 is the key to make it happen.

How it works

What is AI personality of an NFT?

The AI Personality of an NFT is defined by three core components:

• Base LLM: A collection-level base language model that can comprehend and generate human language text. It provides basic AI capabilities for your NFT.

• Trait model: A collection-level function that inputs an NFT's traits and outputs a set of prompts, defining the NFT's independent personality that is only related to its traits, as an initial state.

• Memory: A shared memory between you and your NFT, manifested as the contexts through conversation with the NFT AI.

  • Public Memory: A predefined memory that anyone can use it as their shared memory with NFT AI.

  • Private Memory: A user-level private memory that can be only read by the NFT owner.

In summary, unique AI personality = Bass LLM + Trait model + Memory.

How to index AI personalities on chain?

AI Metadata Standard

AI721 defines a new kind of JSON metadata to describe an AI personality. The metadata standard includes three important parameters to index the AI personality. This metadata is different from the one for ERC721, and can be stored on-chain or off-chain.

Parameter	Type	Description
base_llm_uri	string	The uri to access Base LLM that is stored in off-chain storages, like filecoin/arweaves, or behind an API gateway like GPT4/Gemini/self-host LLM.
trait_model_uri	string	The uri to access Trait model that is stored in off-chain storages.
public_memories_uri	string	(Optional) The uri to access the list of public memories for an NFT. The application layer can choose from these memories to create specific AI personalities, like a virtual lawyer or math teacher.

Trait Model Structure

A Trait model is described as a JSON structure.

Parameter	Type	Description
model	string	The serialized form of a model function that takes a set of traits as input and outputs prompts.
language	string	The programming language the model uses. Support Javascript and Python.

Memory Structure

A memory is described as a JSON structure.

Parameter	Type	Description
name	string	The name of this memory
description	string	The description of this memory
memory	string	The serialized form of this memory.
content_type	string	The content type of this memory
max_size	number	The maximum size of the memory in bytes

How to access the AI personality described in AI metadata?

1. Call aiMetadataURI by tokenId of an AI721 contract, and pull the AI metadata of the NFT.

2. Retrieve the base LLM by base_llm_uri and run as a service;

3. Retrieve the trait model by trait_model_uri. Input the traits set of the NFT to the model to obtain a set of prompts, and then integrate these prompts into the base LLM you get in the previous step;

4. (Optional) Retrieve one of the public memories from the public_memories_uri , and integrate it into the LLM you get in the previous step. This allows you to quickly create a predefined AI personality.

5. Retrieve the private memory (if any) of the NFT owner from local or hosted storages, and integrate it into the LLM in the previous step.

After these steps, you'll get a unique and exclusive AI personality based on a customized LLM, and can be used as your NFT AI agent.

How to make AI personalities indexable on chain?

Base LLM

1. Train and fine-tune your base LLM.

2. Store it in off-chain storages, get the uri of the LLM file.

3. Set base_llm_uri to the uri in the AI metadata.

Trait model

1. Design a function that accepts a set of traits as input parameters and generates a corresponding set of prompts.

2. Stored as a script in decentralized storages, and get the uri of the function file.

3. Set trait_model_uri to the uri in the AI metadata.

Public Memory

1. Create a directory in decentralized storages and set the public_memories_uri field to this path.

2. Upload the public memories you made as different knowledge bases to this directory.

Private Memory

The private memory don't need to be indexed on chain. It can be stored in local or hosted storages like AWS S3, or encrypted and stored in decentralized storages, to protect users' privacy.

URI Format Supported

Format	Description
ipfs://{cid}	The resources stored in IPFS/Filecoin. e.g. ipfs://QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
ar://{cid}	The resources stored in Arweave. e.g. ar://k2g_3kYsPx-meD-AlyHhkUDYbUczlZ-M-bsKO6_oqY4
api://{model}	The hosted API gateway of LLM. Support models: gpt-3.5 gpt-4 The application layer can determine how to access these models' API endpoints, for example, by registering a developer account at openai.com.
http(s)://{domain}/{path}	An typical http(s) url to locate resources.
... More formats from DePIN partners

Implementing token URI of AI metadata

As what you have done for ERC721, you MUST implement tokenURI and return a URI where we can find the metadata.

Best Practice

Merge AIMetadata with ERC721 metadata

You can deploy an AI721 contract inherit from ERC721 to issue NFT AI. In this way, you MUST directly add new AIMetadata fields to ERC721 metadata. The application layer will call tokenURI(uint256 _tokenId) to access the metadata of an NFT and its AI personality directly.

Merged Metadata Example

// Merge AIMetadata with ERC721 metadata 
{
  // ERC721 metadata fields
  "description": "Friendly OpenSea Creature that enjoys long swims in the ocean.", 
  "external_url": "https://openseacreatures.io/3", 
  "image": "https://storage.googleapis.com/opensea-prod.appspot.com/puffs/3.png", 
  "name": "Dave Starbelly",
  "attributes": [ 
    {
      "trait_type": "Base", 
      "value": "Starfish"
    }, 
    {
      "trait_type": "Eyes", 
      "value": "Big"
    }, 
    {
      "trait_type": "Mouth", 
      "value": "Surprised"
    }, 
  ],
  // AIMetadata fields
  "base_llm_uri":"api://gpt-4",
  "trait_model_uri":"ipfs://xxx",
  "public_memories_uri":"ipfs://xxx"
}

AILinker: Link ERC721 to AI721

If your ERC721 contract was already deployed and you want to add AI capabilities for it, you need to deploy an independent AI721 contract, and use AILinker (a public smart contract) to link your ERC721 contract to AI721 contract.

Token URI for AI metadata

The independent AI721 contract MUST implement aiMetadataURI and return a URI where we can find the metadata.

/**
 * @dev Returns the AI metadata URI for a given token ID.
 */
function aiMetadataURI(uint256 _tokenId) public view returns (string memory) {
  string memory baseAIMetadataURI = ''; // Base AI metadata uri for your collection
  return string(abi.encodePacked(
      baseAIMetadataURI,
      _toString(_tokenId)
  ));
}

You can utilize an existing AILinker contract, or deploy your independent one. As the ecosystem grows, creators can link the same ERC721 contract to multiple AI721 contracts across different apps.

Gonesis team will deploy an official AILinker contract, and provide a public UI to facilitate the link configuration for creators.

AILinker Code Snippet

/**
 * @dev Links an ERC721 contract to multiple AI721 contracts.
 * @param erc721Contract The address of the ERC721 contract.
 * @param ai721Contracts An array of addresses representing the AI721 contracts to be linked.
 * 
 * Requirements:
 * 
 * - The caller must be the owner of the input erc721Contract
 * - The input ai721Contracts must impl aiMetadataURI
 */
function linkERC721ToAI721(address erc721Contract, address[] memory ai721Contracts) external {
    // Validate that the caller is the owner of the ERC721 contract
    require(msg.sender == Ownable(erc721Contract).owner(), "AILinker: Caller is not the owner of the ERC721 contract");
    // TODO: Add additional validation for ai721Contracts implementation of aiMetadataURI
    
    // Store the link between the ERC721 contract and the AI721 contracts
    links[erc721Contract] = ai721Contracts;
}

/**
 * @dev Retrieves the AI721 contracts linked to a specific ERC721 contract.
 * @param erc721Contract The address of the ERC721 contract.
 * @return An array of addresses representing the linked AI721 contracts.
 */
function getAI721Contracts(address erc721Contract) external view returns (address[] memory) {
    return links[erc721Contract];
}

Best Practice

We assume you already have deployed an ERC721 contract. So there are the steps to link your ERC721 contract to an AI721 contract. By establishing this link, you can add AI personalities to the NFTs in your ERC721 collection, and enable interaction through the applications.

Step 1: Prepare AI metadata

Prepare AI metadata for your collection according to AI Metadata Standard. If you want a quick start, you can choose from a selection of pre-trained AI metadata that we will make publicly available.

Step 2: Deploy AI721 contract

Deploy the AI721 contract for your ERC721 collection. This contract needs to implement the aiMetaDataURI interface to allow access to the AI metadata of the collection.

Step 3: Link ERC721 to AI721

You must link your ERC721 contract to the AI721 contract you just deployed, in an AILinker contract provided by the app layer. The app layer will use it to see which ERC721 is linked to a specific AI721 collection.

These are the steps to link ERC721 to AI721. By following these steps, you can associate AI metadata with your ERC721 collection, and enable interaction with the AI721 applications.

Please ensure to follow security best practices and perform proper testing and validation of your collection and contracts when deploying the contracts and configuration.

We recommend the application layer to firstly access AI metadata embedded in ERC721 contract to query AI personalities. If not found, then use AILinker to query.

Example

TBD.