feat: dedicated-ai-and-template-section (#263)

added dedicated-ai-and-template-section

## Summary by Sourcery

Add dedicated AI and template sections to the documentation, introducing
new content for blockchain and AI integration, smart contract templates,
and AI-powered development tools

New Features:
- Added comprehensive documentation for Model Context Protocol (MCP)
- Introduced AI code assistant (RooCode) documentation
- Created template libraries for EVM and Fabric smart contracts
- Added OpenAI and pgvector integration guide

Documentation:
- Expanded platform documentation with new sections on AI and blockchain
integration
- Added detailed guides for using AI tools in blockchain development
- Created template documentation for smart contract development

Chores:
- Reorganized documentation structure
- Added new meta.json files for new documentation sections

Author: gyan-sharma

content/docs/blockchain-and-ai/ai-code-assistant.mdx

@@ -0,0 +1,10 @@
+{
+  "title": "Blockchain and AI",
+  "icon": "Brain",
+  "pages": [
+    "blockchain-and-ai",
+    "mcp",
+    "ai-code-assistant",
+    "open-ai-nodes-and-pg-vector"
+  ]
+}

content/docs/blockchain-and-ai/blockchain-and-ai.mdx

@@ -0,0 +1,211 @@
+---
+title: "Open AI nodes and pgvector"
+description:
+  A Guide to Building an AI-Powered Workflow with OpenAI Nodes and Vector
+  Storage in Hasura
+sidebar_position: 2
+keywords: [integration studio, OpenAI, Hasura, pgvector, AI, SettleMint]
+---
+
+This guide will demonstrate how to use the **SettleMint Integration Studio** to
+create a flow that incorporates OpenAI nodes for vectorization and utilizes the
+`pgvector` plugin in Hasura for similarity searches. If you are new to
+SettleMint, check out the
+[Getting Started Guide](/launching-the-platform/managed-cloud-deployment/quickstart).
+
+In this guide, you will learn to create workflows that:
+
+- Use **OpenAI nodes** to vectorize data.
+- Store vectorized data in **Hasura** using `pgvector`.
+- Conduct similarity searches to find relevant matches for new queries.
+
+### Prerequisites
+
+- A SettleMint Platform account with **Integration Studio** and **Hasura**
+  deployed
+- Access to the Integration Studio and Hasura consoles in your SettleMint
+  environment
+- An OpenAI API key for using the OpenAI nodes
+- A data source to vectorize (e.g., Graph Node, Attestation Indexer, or external
+  API endpoint)
+
+### Example Flow Available
+
+The Integration Studio includes a pre-built AI example flow that demonstrates
+these concepts. The flow uses the SettleMint Platform's attestation indexer as a
+data source, showing how to:
+
+- Fetch attestation data via HTTP endpoint
+- Process and vectorize the attestation content
+- Store vectors in Hasura
+- Perform similarity searches
+
+You can use this flow as a reference while building your own implementation.
+Each step described in this guide can be found in the example flow.
+
+---
+
+## Part 1: Creating a Workflow to Fetch, Vectorize, and Store Data
+
+### Step 1: Set Up Vector Storage in Hasura
+
+1. Access your SettleMint's Hasura instance through the admin console.
+
+2. Create a new table called `document_embeddings` with the following columns:
+   - `id` (type: UUID, primary key)
+   - `embedding` (type: vector(1536)) - For storing OpenAI embeddings
+
+### Step 2: Set Up the Integration Studio Flow
+
+1. **Open Integration Studio** in SettleMint and click on **Create Flow** to
+   start a new workflow.
+
+### Step 3: Fetch Data from an External API
+
+1. **Add an HTTP Request Node** to retrieve data from an external API, such as a
+   document or product listing service.
+2. Configure the **API endpoint** and any necessary authentication settings.
+3. **Add a JSON Node** to parse the response data, focusing on fields like `id`
+   and `content` for further processing.
+
+### Step 4: Vectorize Data with OpenAI Node
+
+1. **Insert an OpenAI Node** in the workflow:
+   - Use this node to generate vector embeddings for the text data using
+     OpenAI's Embedding API.
+   - Configure the OpenAI node to use the appropriate model and input data, such
+     as `text-embedding-ada-002`.
+
+![Create an OpenAI node](../../img/developer-guides/openai-node.png)
+
+### Step 5: Store Vectors in Hasura with pgvector
+
+1. **Add a GraphQL Node** to save the vector embeddings and data `id` in Hasura.
+2. Set up a **GraphQL Mutation** to store the vectors and associated IDs in a
+   table enabled with `pgvector`.
+
+Example Mutation:
+
+```graphql
+mutation insertVector($id: uuid!, $vector: [Float!]!) {
+  insert_vectors(objects: { id: $id, vector: $vector }) {
+    affected_rows
+  }
+}
+```
+
+3. Ensure correct data mapping from the fetched data and vectorized output.
+
+### Step 6: Deploy and Test the Workflow
+
+1. **Deploy the Flow** within Integration Studio and **run it** to confirm that
+   data is fetched, vectorized, and stored in Hasura.
+2. **Verify Hasura Data** by checking the table to ensure vectorized entries and
+   corresponding IDs are stored correctly.
+
+---
+
+## Part 2: Setting Up a Similarity Search Endpoint
+
+### Step 1: Create a POST Endpoint
+
+1. **Add an HTTP POST Node** to accept a JSON payload with a `query` string to
+   be vectorized and compared to stored data.
+
+Payload Example:
+
+```json
+{
+  "query": "input string for similarity search"
+}
+```
+
+2. **Parse the Request** by adding a JSON node to extract the `query` field from
+   the incoming POST request.
+
+### Step 2: Vectorize the Input Query
+
+1. **Add an OpenAI Node** to convert the incoming `query` string into a vector
+   representation.
+
+Example Configuration:
+
+```text
+Model: text-embedding-ada-002
+Input: {{msg.payload.query}}
+```
+
+### Step 3: Perform a Similarity Search with Hasura
+
+1. **Add a GraphQL Node** to perform a vector similarity search within Hasura
+   using the `pgvector` plugin.
+2. Use a **GraphQL Query** to order results by similarity, returning the top 5
+   most similar records.
+
+Example Query:
+
+```graphql
+query searchVectors($vector: [Float!]!) {
+  vectors(order_by: { vector: { _vector_distance: $vector } }, limit: 5) {
+    id
+    vector
+  }
+}
+```
+
+3. Map the vector from the OpenAI node output as the `vector` input for the
+   Hasura query.
+
+### Step 4: Format and Return the Results
+
+1. **Add a Function Node** to format the response, listing the top 5 matches in
+   a structured JSON format.
+
+### Step 5: Test the Flow
+
+1. **Deploy the Flow** and send a POST request to confirm the similarity search
+   functionality.
+2. **Verify Response** to ensure that the flow accurately returns the top 5
+   matches from the vectorized data in Hasura.
+
+---
+
+## Next Steps
+
+Now that you have built an AI-powered workflow, here are some
+blockchain-specific applications you can explore:
+
+### Vectorize On-Chain Data
+
+- Index and vectorize smart contract events for similarity-based event
+  monitoring
+- Create embeddings from transaction data to detect patterns or anomalies
+- Vectorize NFT metadata for content-based recommendations
+- Build semantic search for on-chain attestations
+
+### Advanced Use Cases
+
+- Combine transaction data with natural language descriptions for enhanced
+  search
+- Create AI-powered analytics dashboards using vectorized blockchain metrics
+- Implement fraud detection by vectorizing transaction patterns
+- Build a semantic search engine for smart contract code and documentation
+
+### Integration Ideas
+
+- Connect to multiple blockchain indexers to vectorize data across networks
+- Combine off-chain and on-chain data vectors for comprehensive analysis
+- Set up automated alerts based on similarity to known patterns
+- Create a knowledge base from vectorized blockchain documentation
+
+For further resources, check out:
+
+- [SettleMint Integration Studio Documentation](/building-with-settlemint/integration-studio/)
+- [Node-RED Documentation](https://nodered.org/docs/)
+- [OpenAI API Documentation](https://openai.com/docs/)
+- [Hasura pgvector Documentation](https://hasura.io/docs/3.0/connectors/postgresql/native-operations/vector-search/)
+
+---
+
+This guide should enable you to build AI-powered workflows with SettleMint's new
+OpenAI nodes and `pgvector` support in Hasura for efficient similarity searches.

content/docs/blockchain-and-ai/mcp.mdx

@@ -100,7 +100,7 @@ identities, or events that can be independently verified by others.
 
 ---
 
-## 3. How eas works
+## 3. How EAS works
 
 ```mermaid
 graph TD
@@ -303,7 +303,7 @@ const config = {
 // Connect to the blockchain
 const provider = new ethers.JsonRpcProvider(config.rpcUrl);
 const signer = new ethers.Wallet(config.privateKey, provider);
-const eas = new EAS(config.easAddress);
+const EAS = new EAS(config.easAddress);
 eas.connect(signer);
 
 // Create an encoder that matches our schema structure
@@ -363,7 +363,7 @@ attestations. You can verify attestations using one of the following methods:
 <Tabs>
 <Tab value="eas-sdk" label="Using the EAS SDK">
 
-#### Verification using the eas sdk
+#### Verification using the EAS sdk
 
 The EAS SDK provides an easy way to verify attestations programmatically, making
 it ideal for off-chain use cases.
@@ -383,7 +383,7 @@ const config = {
 async function verifyAttestation(attestationUID) {
   // Setup our blockchain connection
   const provider = new ethers.JsonRpcProvider(config.rpcUrl);
-  const eas = new EAS(config.easAddress);
+  const EAS = new EAS(config.easAddress);
   eas.connect(provider);
 
   console.log("🔍 Verifying attestation:", attestationUID);
@@ -638,7 +638,7 @@ The flow includes:
     "id": "setup_inject",
     "type": "inject",
     "z": "eas_flow",
-    "name": "Inputs: RpcUrl, registry address, eas address, private key",
+    "name": "Inputs: RpcUrl, registry address, EAS address, private key",
     "props": [
       {
         "p": "rpcUrl",
@@ -675,7 +675,7 @@ The flow includes:
     "type": "function",
     "z": "eas_flow",
     "name": "Setup global variables",
-    "func": "// Initialize provider with specific network parameters\nconst provider = new ethers.JsonRpcProvider(msg.rpcUrl)\n\nconst signer = new ethers.Wallet(msg.privateKey, provider);\n\n// Initialize EAS with specific gas settings\nconst eas = new eassdk.EAS(msg.easAddress);\neas.connect(signer);\n\n// Store in global context\nglobal.set('provider', provider);\nglobal.set('signer', signer);\nglobal.set('eas', eas);\nglobal.set('registryAddress', msg.registryAddress);\n\nmsg.payload = 'EAS configuration initialized';\nreturn msg;",
+    "func": "// Initialize provider with specific network parameters\nconst provider = new ethers.JsonRpcProvider(msg.rpcUrl)\n\nconst signer = new ethers.Wallet(msg.privateKey, provider);\n\n// Initialize EAS with specific gas settings\nconst EAS = new eassdk.EAS(msg.easAddress);\neas.connect(signer);\n\n// Store in global context\nglobal.set('provider', provider);\nglobal.set('signer', signer);\nglobal.set('eas', eas);\nglobal.set('registryAddress', msg.registryAddress);\n\nmsg.payload = 'EAS configuration initialized';\nreturn msg;",
     "outputs": 1,
     "timeout": "",
     "noerr": 0,
@@ -757,7 +757,7 @@ The flow includes:
     "type": "function",
     "z": "eas_flow",
     "name": "Create attestation",
-    "func": "// Get global variables\nconst eas = global.get('eas');\nconst schemaUID = msg.schemaUID;\n\n// Create an encoder that matches our schema structure\nconst schemaEncoder = new eassdk.SchemaEncoder(\"string username, string platform, string handle\");\n\n// The actual data we want to attest to\nconst attestationData = [\n    { name: \"username\", value: \"awesome_developer\", type: \"string\" },\n    { name: \"platform\", value: \"GitHub\", type: \"string\" },\n    { name: \"handle\", value: \"@devmaster\", type: \"string\" }\n];\n\ntry {\n    // Convert our data into the format EAS expects\n    const encodedData = schemaEncoder.encodeData(attestationData);\n\n    // Create the attestation\n    const tx = await eas.attest({\n        schema: schemaUID,\n        data: {\n            recipient: \"0x0000000000000000000000000000000000000000\",  // Public attestation\n            expirationTime: 0,              // Never expires\n            revocable: true,                // Can be revoked later if needed\n            data: encodedData              // Our encoded attestation data\n        }\n    });\n\n    // Wait for confirmation and get the result\n    const receipt = await tx.wait();\n\n    // Store attestation UID for later verification\n    global.set('attestationUID', receipt.attestationUID);\n\n    msg.payload = {\n        success: true,\n        attestationUID: receipt,\n        message: \"Attestation created successfully!\"\n    };\n} catch (error) {\n    msg.payload = {\n        success: false,\n        error: error.message\n    };\n}\n\nreturn msg;",
+    "func": "// Get global variables\nconst EAS = global.get('eas');\nconst schemaUID = msg.schemaUID;\n\n// Create an encoder that matches our schema structure\nconst schemaEncoder = new eassdk.SchemaEncoder(\"string username, string platform, string handle\");\n\n// The actual data we want to attest to\nconst attestationData = [\n    { name: \"username\", value: \"awesome_developer\", type: \"string\" },\n    { name: \"platform\", value: \"GitHub\", type: \"string\" },\n    { name: \"handle\", value: \"@devmaster\", type: \"string\" }\n];\n\ntry {\n    // Convert our data into the format EAS expects\n    const encodedData = schemaEncoder.encodeData(attestationData);\n\n    // Create the attestation\n    const tx = await eas.attest({\n        schema: schemaUID,\n        data: {\n            recipient: \"0x0000000000000000000000000000000000000000\",  // Public attestation\n            expirationTime: 0,              // Never expires\n            revocable: true,                // Can be revoked later if needed\n            data: encodedData              // Our encoded attestation data\n        }\n    });\n\n    // Wait for confirmation and get the result\n    const receipt = await tx.wait();\n\n    // Store attestation UID for later verification\n    global.set('attestationUID', receipt.attestationUID);\n\n    msg.payload = {\n        success: true,\n        attestationUID: receipt,\n        message: \"Attestation created successfully!\"\n    };\n} catch (error) {\n    msg.payload = {\n        success: false,\n        error: error.message\n    };\n}\n\nreturn msg;",
     "outputs": 1,
     "timeout": "",
     "noerr": 0,
@@ -803,7 +803,7 @@ The flow includes:
     "type": "function",
     "z": "eas_flow",
     "name": "Verify attestation",
-    "func": "const eas = global.get('eas');\nconst attestationUID = msg.attestationUID;\n\ntry {\n    const attestation = await eas.getAttestation(attestationUID);\n    const schemaEncoder = new eassdk.SchemaEncoder(\"string pshandle, string socialMedia, string socialMediaHandle\");\n    const decodedData = schemaEncoder.decodeData(attestation.data);\n\n    msg.payload = {\n        isValid: !attestation.revoked,\n        attestation: {\n            attester: attestation.attester,\n            time: new Date(Number(attestation.time) * 1000).toLocaleString(),\n            expirationTime: attestation.expirationTime > 0 \n                ? new Date(Number(attestation.expirationTime) * 1000).toLocaleString()\n                : 'Never',\n            revoked: attestation.revoked\n        },\n        data: {\n            psHandle: decodedData[0].value.toString(),\n            socialMedia: decodedData[1].value.toString(),\n            socialMediaHandle: decodedData[2].value.toString()\n        }\n    };\n} catch (error) {\n    msg.payload = { \n        success: false, \n        error: error.message,\n        details: JSON.stringify(error, Object.getOwnPropertyNames(error))\n    };\n}\n\nreturn msg;",
+    "func": "const EAS = global.get('eas');\nconst attestationUID = msg.attestationUID;\n\ntry {\n    const attestation = await eas.getAttestation(attestationUID);\n    const schemaEncoder = new eassdk.SchemaEncoder(\"string pshandle, string socialMedia, string socialMediaHandle\");\n    const decodedData = schemaEncoder.decodeData(attestation.data);\n\n    msg.payload = {\n        isValid: !attestation.revoked,\n        attestation: {\n            attester: attestation.attester,\n            time: new Date(Number(attestation.time) * 1000).toLocaleString(),\n            expirationTime: attestation.expirationTime > 0 \n                ? new Date(Number(attestation.expirationTime) * 1000).toLocaleString()\n                : 'Never',\n            revoked: attestation.revoked\n        },\n        data: {\n            psHandle: decodedData[0].value.toString(),\n            socialMedia: decodedData[1].value.toString(),\n            socialMediaHandle: decodedData[2].value.toString()\n        }\n    };\n} catch (error) {\n    msg.payload = { \n        success: false, \n        error: error.message,\n        details: JSON.stringify(error, Object.getOwnPropertyNames(error))\n    };\n}\n\nreturn msg;",
     "outputs": 1,
     "timeout": "",
     "noerr": 0,