# Welcome to Gaia These docs are a guide for both developers and non-developers. If you’d like to know what GaiaNet does, how to get involved, or how to use it, you’re in the perfect place! ## What is Gaia? GaiaNet is revolutionizing AI by offering a decentralized computing infrastructure that empowers individuals and businesses to create, deploy, scale, and monetize their own AI services using proprietary data. Our mission is to unlock living knowledge systems, ensuring these AI services reflect the unique styles, values, knowledge, and expertise of their creators. ### What do we do? We enable individuals and businesses alike to create and customize AI agents based on their individual needs and expertise. ### What is this handbook? This is your guide to everything GaiaNet. Communities, especially ones like ours, can be perplexing and overwhelming, so we aim for this handbook to make it easy to understand and find your way in Gaia. We’re excited that you’re here, let’s make sure we stay in touch! * Join us on [Discord](https://discord.com/invite/gaianet-ai) * Join our Developer [Telegram](https://t.me/+a0bJInD5lsYxNDJl) * Follow us on [X](https://x.com/Gaianet_AI) * Follow us on [Medium](https://medium.com/@Gaianet.ai) Now that you're staying in touch, you're ready to take your [First Steps](#first-steps)... # Translations ## [한국어](https://ko.developer.gaianet.ai) ## [Español](https://es.developer.gaianet.ai/) ## [Português](https://pt.developer.gaianet.ai/) ## [Türkçe](https://tr.developer.gaianet.ai/) ## [Tiếng Việt](https://vi.developer.gaianet.ai/) # First Steps Here's ways that you can get started with Gaia As an Open Source project, much of what we do is free to everyone as a public good. Here are a few ways that you can get started. {% content-ref url="/spaces/Gjhz2bnyiEt8FqZJwwjV/pages/P2s2dG5ppDhb0qtCjaXB" %} [Setting up your Node](/getting-started-as-a-developer/setting-up-your-node) {% endcontent-ref %} {% content-ref url="/pages/gFnPoSvkW9uPKru31fec" %} [Contribute to the Open Source Project](/getting-started-as-a-developer/contribute-to-the-open-source-project) {% endcontent-ref %} # Contribute to the Open Source Project As a developer, you can contribute to the open source project through these things: {% content-ref url="/pages/ZGeAKmxbHaMrB394WV8X" %} [Code](/getting-started-as-a-developer/contribute-to-the-open-source-project/code) {% endcontent-ref %} {% content-ref url="/pages/8WkJv7ih5NI8uFwyhqMx" %} [Documentation](/getting-started-as-a-developer/contribute-to-the-open-source-project/documentation) {% endcontent-ref %} {% content-ref url="/pages/BQpZxcS3nFWgPuyrL6GF" %} [Community](/getting-started-as-a-developer/contribute-to-the-open-source-project/community) {% endcontent-ref %} # Code ## **Enhance GaiaNet with Code Contributions** Developers can fork our repository on [GitHub](https://github.com/GaiaNet-AI), make improvements or add new features, and submit pull requests (PRs) for review. Regular contributors can be invited to join our core team and take on larger responsibilities. ### Gather Context Before making your contribution, you want to ensure that it has not already been discussed or done elsewhere. You can skim the repo's README and issues (both open and closed). If you do not see what you're planning to contribute elsewhere, you can: * **Raise an issue:** this is essentially like starting a conversation or discussion * **Create a PR:** this will allow you to start work on a solution * **Visit our** [**Discord channel**](https://discord.com/invite/gaianet-ai)**:** this will allow you to start a conversation or ask for clarification about your contribution. ### Starting your Pull Request 1. Fork the repository: * Visit the [GaiaNet node](https://github.com/GaiaNet-AI/gaianet-node) repository on GitHub * Click the "Fork" button in the top-right corner * Select where you want to fork the repository (your personal account or an organization) 2. Clone your forked repository: ``` git clone https://github.com/GaiaNet-AI/gaianet-node.git ``` 3. Create a new branch for your changes: ``` git checkout -b your-feature-branch ``` 4. Reference any relevant issues or supporting documentation in your PR 1. Include screenshots of the before and after, you can drag and drop the images into the body of your PR. 5. Test your changes to ensure that your changes do not break the project. 1. Also be sure that your changes are created with the same style and syntax as your 6. Commit your changes: ``` git add . git commit -m "Description of your changes" ``` 7. Push your changes to your fork: ``` git push origin your-feature-branch ``` 8. Create a pull request: * Go to your fork on GitHub * Click "Pull request" and select "New pull request" * Select your feature branch and submit the pull request * **Participate in GitHub Activity** By opening issues, suggesting improvements, and engaging in discussions, developers help identify bugs and propose new functionalities. Active participants can earn recognition and rewards. # Documentation Help expand GaiaNet’s documentation, making it easier for new developers to get started, here's how you can get started! ## Contributing 1. Fork the repository: * Visit the [GaiaNet docs repository](https://github.com/GaiaNet-AI/docs) on GitHub * Click the "Fork" button in the top-right corner * Select where you want to fork the repository (your personal account or an organization) 2. Clone your forked repository: ``` git clone https://github.com/YOUR-USERNAME/docs.git cd docs ``` 3. Create a new branch for your changes: ``` git checkout -b your-feature-branch ``` 4. Make your changes to the documentation 5. Commit your changes: ``` git add . git commit -m "Description of your changes" ``` 6. Push your changes to your fork: ``` git push origin your-feature-branch ``` 7. Create a pull request: * Go to your fork on GitHub * Click "Pull request" and select "New pull request" * Select your feature branch and submit the pull request\ Please ensure your contributions align with our documentation style and standards. ### Running the Documentation Locally After forking and cloning the repository: 1. Install dependencies: ``` npm install ``` 2. Start the development server: ``` npm start ``` 3. Open your browser and visit `http://localhost:3000` ### Structure * `docs/`: Contains all the markdown files for the documentation * `src/`: Custom React components and pages * `static/`: Static assets like images * `docusaurus.config.js`: Main configuration file for Docusaurus ### Deployment This documentation is automatically deployed to [docs.gaianet.ai](https://docs.gaianet.ai/) when changes are merged into the main branch. ### Need Help? If you have any questions or need assistance, please open an issue in the repository or reach out through our community channels.\
# Community * **Join Our OSS Core Calls** Participate in our bi-weekly open-source software (OSS) core calls to discuss ongoing projects, get feedback, and synchronize with the community. * **Engage the Community** Developers are encouraged to invite other developers from their networks to contribute, fostering a broader and more diverse community. * **Provide Feedback** Offer valuable insights and suggestions to help us continuously improve the platform. If you have any tutorials or workshops, please share them with the community. Through your contributions you can help the community grow! # Setting up your Node Now that you have the ways to contribute to the open source project, let's make sure that you know how to do it. ### System requirements To successfully deploy a node, you need the follow at minimum: | Component | Model | | -------------------- | ----------------------------------- | | **Operating System** | Mac, Linux, Windows (will need WSL) | | **GPU** | Optional | | **Processor** | 2 core vCPUs | | **RAM** | 8GB | | **Storage** | 10GB of free space | | **Network** | Internet | ## Node Installation Quick Start 1. Install the one-line script to download the latest version of the GaiaNet node ``` /curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash ``` 2. Initialize the node using the configuration options in `$HOME/gaianet/config.json` : `gaianet init` 3. (By default, GaiaNet is initialized with a [Phi-3](https://azure.microsoft.com/en-us/blog/introducing-phi-3-redefining-whats-possible-with-slms/) LLM and a [Paris knowledge base](https://huggingface.co/datasets/gaianet/paris).) 4. Start your node: `gaianet start` 5. Upon a successful start, the command will print a public UPL for the node. Open a browser tab to that URL to see the node information and chat with the AI agent on the node. To stop the node: `gaianet stop` ### OpenAI API Replacement After your node is created, you can use it as a an OpenAI compatible web service. By simply opening the node's dashboard and pasting the node's public URL into the browser, the dashboard will display a table providing all parameters needing to be replaced.
GaiaNet dashboard displaying the configuration options and values for OpenAI's API

GaiaNet dashboard config details

## Starting a node with Docker To quickly start a node using Docker, run this command: ``` docker run --name gaianet \ -p 8080:8080 \ -v $(pwd)/qdrant_storage:/root/gaianet/qdrant/storage:z \ gaianet/phi-3-mini-instruct-4k_paris:latest ``` #### Docker Node Installation with NVIDIA CUDA 12 machine ``` docker run --name gaianet \ -p 8080:8080 --device nvidia.com/gpu=all \ -v $(pwd)/qdrant_storage:/root/gaianet/qdrant/storage:z \ gaianet/phi-3-mini-instruct-4k_paris:cuda12 ``` You'll know your node is ready when the console shows `The GaiaNet node is started at: https://...` . To interact with the node, open that URL in a browser window. ### Stopping and restarting your node ``` docker stop gaianet docker start gaianet ``` #### Considerations for restarting node Each time the node is restarted, the vector collection (knowledge base) will be re-initialized. Additionally, when the node is restarted, the log messages are no longer printed to the console. They can still be seen by logging into the container: ``` docker exec -it gaianet /bin/bash tail -f /root/gaianet/log/start-llamaedge.log ``` ### Deleting your node If your node is no longer needed, it can simply be deleted by running these commands: ``` docker stop gaianet docker rm gaianet ``` ### Configuring your node #### Making Changes The configuration parameters of the node can be updated by executing the `config` command on the `gaianet` program within the container. After all the necessary commands are run to make the changes, the node must be restarted for the new configuration to take effect. **Changing the node ID** The node ID (Ethereum address) associated with is easily updated. 1. Start the node 2. Copy the `nodeid.json` file and the keystore file defined in `nodeid.json` into the container. ``` docker cp /local/path/to/nodeid.json gaianet:/root/gaianet/nodeid.json docker cp /local/path/to/1234-abcd-key-store gaianet:/root/gaianet/1234-abcd-key-store ``` 3. Restart the node for the new address and keystore to take effect. ### Publishing your node for others to use ``` docker push gaianet/phi-3-mini-instruct-4k_paris:latest ``` Now that you've completed the node installation, you can get started on building your plugins and integrations! # Customizing your node We want to enable you to create and run your own agent service node. You probably won't be using the default Phi-3 LLM and Paris guidebook knowledge base. So let's show you how to customize your node! ## Pre-set configurations[​](https://docs.gaianet.ai/node-guide/customize#pre-set-configurations) The `gaianet/config.json` file hold all node configuration options, like the LLM settings, vector collection for the knowledge base and prompts. You can either edit this file directly to use your models and vector collections, or you can select a different `config.json` when you initialize the node. Simply pass in a URL to the `config.json` file in your `gaianet init` command, the URL to the `config.json` must point to the actual text file. We have several pre-set `config.json` files to choose from [in this repo](https://github.com/GaiaNet-AI/node-configs). For example, the following command initializes a GaiaNet node with a Llama 3 8B model: ``` gaianet init --config https://raw.githubusercontent.com/GaiaNet-AI/node-configs/main/llama-3-8b-instruct/config.json ``` ## The config subcommand[​](https://docs.gaianet.ai/node-guide/customize#the-config-subcommand) Even after initializing the node, you are able to make changes to its configuration by editing the `config.json` file. However, it is a best practice to use the `gaianet` CLI in order to make the changes as it is safer and easier. After any changes have been made to the node configuration, the`gaianet init` command MUST be run. `gaianet config list` command shows the `config.json` fields that are able to be changed. ## Selecting an LLM[​](https://docs.gaianet.ai/node-guide/customize#select-an-llm) Huggingface has over 10,000 fine-tuned, open-source LLMs to choose from. Each of them have different sizes (the larger models are more capable yet more expensive to run), unique capabilities (for example, some can support large context length, are uncensored, or excel in math), domain expertise (like coding or medicine), and/or styles (some respond in code, can speak like a pirate, etc). Making changes to the model file, prompt template, and model context length parameters will allow you to replace your node's default LLM with an alternative fine-tuned model. The parameters vary depending on the model, but they can be found on the [gaianet Huggingface organization's](https://huggingface.co/gaianet) model cards. For example, the following command changes the LLM to a Llama 3 8B model: ``` gaianet config \ --chat-url https://huggingface.co/gaianet/Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct-Q5_K_M.gguf \ --chat-ctx-size 4096 \ --prompt-template llama-3-chat ``` > The llama 3 8B model requires at least 16GB of RAM. If none of the published fine-tuned models are perfect for your use case, you can also fine-tune your own LLM by following [these guides](https://docs.gaianet.ai/creator-guide/finetune/intro). Your GaiaNet node can run your own fine-tuned models. > The `--chat-url` argument could point to a local file under `$HOME/gaianet` instead of a public URL. That allows you to use a privately trained or fine-tuned LLM model file. ## Selecting a knowledge base[​](https://docs.gaianet.ai/node-guide/customize#select-a-knowledge-base) A key feature of GaiaNet is that users can create and deploy proprietary knowledge base on the node to supplement the LLM. Each knowledge base is a snapshot file for a vector collection. You can use ready-made knowledge bases, but we encourage you to [create your own knowledge base](https://docs.gaianet.ai/creator-guide/knowledge/concepts) . You will need to do the following: 1. specify the URL to the vector collection (i.e., the `snapshot` or `snapshot.tar.gz` file) in the `snapshot` option. 2. use the same embedding model that generated this vector collection. 3. modify the `system_prompt` to give the model background knowledge. 4. modify the `rag_prompt` to instruct the model to answer the question when context is retrieved from the vector collection. The following example changes the knowledge base in the node from "Paris guidebook" to "London guidebook": ``` gaianet config \ --snapshot https://huggingface.co/datasets/gaianet/london/resolve/main/london_768_nomic-embed-text-v1.5-f16.snapshot.tar.gz \ --embedding-url https://huggingface.co/gaianet/Nomic-embed-text-v1.5-Embedding-GGUF/resolve/main/nomic-embed-text-v1.5.f16.gguf \ --embedding-ctx-size 8192 \ --system-prompt "You are a tour guide in London, UK. Please answer the question from a London visitor accurately." \ --rag-prompt "The following text is the context for the user question.\n----------------\n" ``` > The `--snapshot` could point to a local file under `$HOME/gaianet` instead of a public URL. That allows you to use a private vector collection snapshot. Depending on the quality and size of the vectors, you might also need to change the `qdrant-` options to customize the retrieval behavior. * `qdrant-limit` sets the max number of relevant context to add to the prompt. If your knowledge base consists of large sections of text (i.e., each book chapter is a vector), you should probably make this 1 or 2 to limit the prompt length to a reasonable size. * `qdrant-score-threshold` is the min match "score" the knowledge content must meet in order to be considerred "relevant". This depends on the quality of the knowledge text and the embedding model. In general, this score should be over 0.5 to reduce irrelevant context in the prompt. > The embedding model encodes and transforms text into vectors so that the can be stored, searched and retrieved. For different context material, you might need a different embedding model to achieve the optimal performance. The [MTEB leaderboard](https://huggingface.co/spaces/mteb/leaderboard) is a good place to see the performance benchmarks of embedding models. You can find many of them in the [gaianet organization on Huggingface](https://huggingface.co/gaianet). ## Customizing prompts[​](https://docs.gaianet.ai/node-guide/customize#customize-prompts) In `config.json`, you can also customize the prompts. Prompts are often tailored for the fine-tuned LLM or the knowledge base to generate optimal responses from the node. The `--system-prompt` option sets a system prompt. It provides the background and "personality" of the node. Each API request can set its own system prompt. The `--rag-prompt` is the prompt to be appended after the system prompt (or user query). It introduces the RAG context retrieved from the vector database, which follows it. The `--rag-policy` option specifies where the `rag-prompt` and context should go. By default, its value is `system-message` and it puts the context in the system prompt. But you could also set it to `last-user-message`, which puts the `rag-prompt` and context in front of the latest message from the user. ### Next steps[​](https://docs.gaianet.ai/node-guide/customize#next-steps) Remember to re-initialize and re-start the node after you make configuration changes. ``` # If the node is running: gaianet stop gaianet init gaianet start ``` # Joining the protocol You have a node running successfully on your machine, now it's time to joinhe GaiaNet protocol network and get rewards for sharing computing power with the world by binding your node ID and device ID. When you run a node with the Getting Started guide, you may notice that the GaiaNet software has generated a node ID for you. The node ID is an ETH address. The easiest way to find the node ID is to use `gaianet info` to print the node ID and device ID on the terminal. ``` gaianet info ``` The output will be the following: ``` Node ID: 0x80642b1----9a76a284efeb2bb6d142e Device ID: device-e77---1446f1b51 ```
To receive your rewards, all you need to do is bind your node ID and device id with a Metamask account via the GaiaNet web portal: 1. Open on your browser and log in to the website with your Metamask account 2. Select the **Node** section by clicking on your account, then click on the +Add Node button. Next, 3. Copy and paste your node ID into the relevant field and do the same for the device ID in the second box. Then, click on the Join button.
* After your node is joined successfully, it will be displayed in the list of nodes on the Node Page.
* You can bind multiple node ID and its corresponding device ids to your MetaMask wallet address if you are running multiple nodes. > Please do not share the device id with others. ## Protecting your node ID and device ID[​](https://docs.gaianet.ai/node-guide/register#protect-your-node-id-and-device-id) The GaiaNet installer generates a pair of ETH address and keystore and password for your node automatically. This information is stored in the `gaianet/nodeid.json` file. Please keep the JSON file carefully. * The ETH address is your node ID. You will use this ETH address to join the GaiaNet network. * The keystore stores the private key associated with the ETH address encrypted by the password. The `nodeid.json` is the only proof that your node belongs to you. In many protocol operations, you will need this private key to sign request messages to send to the protocol smart contracts. The device id is only visible to yourself. ## Selecting a different domain[​](https://docs.gaianet.ai/node-guide/register#select-a-different-domain) By default, a new GaiaNet node joins the `gaianet.network` domain. You can select a different domain to join by putting the GaiaNet domain's public DNS name in the `domain` field in the `config.json`. Please note that most GaiaNet domains require approval for nodes to join. You have to abide by the domain's rules before your node becomes publicly accessible on the domain URL.
# Agent Integrations and Plugins You can improve functionality of your node through integrations and plugins. Your node can be used as the backend service for an agent framework or app, and replace the OpenAI API. * **Enhance Performance** Create integrations or plugins that improve GaiaNet’s core protocol functionality. This could involve optimizing data processing, enhancing security, or adding new capabilities. * **Innovate with Unique Tools** Develop unique tools and applications leveraging GaiaNet’s decentralized infrastructure. These innovations can be shared with the community, increasing the overall utility of the platform. * **Use Comprehensive Documentation and SDKs** Gaia provides comprehensive documentation and software development kits (SDKs) to simplify the integration process, making it easier for developers to build and deploy their plugins. ## Current Agent Frameworks Available
Open AI Ecosystem Appshttps://docs.gaianet.ai/user-guide/apps/intro
Dify + GaiaNethttps://docs.gaianet.ai/user-guide/apps/dify
Open WebUIhttps://docs.gaianet.ai/user-guide/apps/openwebui
Anything LLMhttps://docs.gaianet.ai/user-guide/apps/anything_llm
Cursor AI IDEhttps://docs.gaianet.ai/user-guide/apps/cursor
Stockbothttps://docs.gaianet.ai/user-guide/apps/stockbot
FlowiseAI RAGhttps://docs.gaianet.ai/user-guide/apps/flowiseai
Flowise AI Tool Callhttps://docs.gaianet.ai/user-guide/apps/flowiseai-tool-call
LobeChathttps://docs.gaianet.ai/user-guide/apps/lobechat
LlamaCloudhttps://docs.gaianet.ai/user-guide/apps/llamaparse
Obsidianhttps://docs.gaianet.ai/user-guide/apps/obsidian
CodeGPThttps://docs.gaianet.ai/user-guide/apps/codegpt
LlamaCoderhttps://docs.gaianet.ai/user-guide/apps/llamacoder
Translation Agent + GaiaNethttps://docs.gaianet.ai/user-guide/apps/translation-agent
Planning Agenthttps://docs.gaianet.ai/user-guide/apps/gpt-planner
LlamaEdgeBookhttps://docs.gaianet.ai/user-guide/apps/llamaedgebook

LlamaTutor

https://docs.gaianet.ai/user-guide/apps/llamatutor
# Troubleshooting your node Below are some common issues that you may run into with your node, here's how to fix them! ## The system cannot find CUDA libraries[​](https://docs.gaianet.ai/node-guide/troubleshooting#the-system-cannot-find-cuda-libraries) Sometimes, the CUDA toolkit is installed in a non-standard location. The error message here is often not able to find `libcu*12`. For example, you might have CUDA installed with your Python setup. The following command would install CUDA into Python's enviornment. ``` sudo apt install python3-pip -y pip3 install --upgrade fschat accelerate autoawq vllm ``` The easiest way to fix is simply to link those non-standard CUDA libraries to the standard location, like this: ``` ln -s /usr/local/lib/python3.10/dist-packages/nvidia/cublas/lib/libcublas.so.12 /usr/lib/libcublas.so.12 ln -s /usr/local/lib/python3.10/dist-packages/nvidia/cuda_runtime/lib/libcudart.so.12 /usr/lib/libcudart.so.12 ln -s /usr/local/lib/python3.10/dist-packages/nvidia/cublas/lib/libcublasLt.so.12 /usr/lib/libcublasLt.so.12 ``` ## Failed to recover from collection snapshot on Windows WSL[​](https://docs.gaianet.ai/node-guide/troubleshooting#failed-to-recover-from-collection-snapshot-on-windows-wsl) On Windows WSL, you could see this error while running `gaianet init:` `Import the Qdrant collection snapshot ... The process may take a few minutes. Please wait ... * [Error] Failed to recover from the collection snapshot. {"status":{"error":"Service internal error: Tokio task join error: task 1242 panicked"},"time":0.697784244}` When you look into the `~/gaianet/log/init-qdrant.log` file, you could see this line of error: ``` 2024-05-20T07:24:52.900895Z ERROR qdrant::startup: Panic occurred in file /home/runner/.cargo/registry/src/index.crates.io-6f17d22bba15001f/cgroups-rs-0.3.4/src/memory.rs at line 587: called `Result::unwrap()` on an `Err` value: Error { kind: ReadFailed("/sys/fs/cgroup/memory.high"), cause: Some(Os { code: 2, kind: NotFound, message: "No such file or directory" }) } ``` The solution is to disable the `autoMemoryReclaim` feature in WSL. Step to turn on/off this feature: 1. Edit `C:\Users.wslconfig` 2. Remove or comment out `autoMemoryReclaim` in `[experimental]` section.
You can learn more about it [here](https://github.com/GaiaNet-AI/gaianet-node/issues/46), this was discovered by [RoggeOhta](https://github.com/RoggeOhta). ## Failed to start the node with an error message `Port 8080 is in use. Exit ...`[​](https://docs.gaianet.ai/node-guide/troubleshooting#failed-to-start-the-node-with-an-error-message-port-8080-is-in-use-exit-) You may see the following error when you run `gaianet start`. ``` gaianet start [+] Checking the config.json file ... You already have a private key. [+] Starting LlamaEdge API Server ... Port 8080 is in use. Exit ... ``` The solution is to run `gaianet stop` first to kill all processes, and then run `gaianet start` to start the node. ## Load library failed: libgomp.so.1: cannot open shared object file: No such file or directory[​](https://docs.gaianet.ai/node-guide/troubleshooting#load-library-failed-libgompso1-cannot-open-shared-object-file-no-such-file-or-directory) On Windows WSL, you may see this error when running `curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash` ``` * Generate node IS [2024-07-02 17:50:55.175] [error] loading failed: invalid path, Code: 0x20 [2024-07-02 17:50:55.175] [error] Load library failed: libgomp.so.1: cannot open shared object file: No such file or directory [2024-07-02 17:50:55.176] [error] loading failed: invalid path, Code: 0x20 [2024-07-02 17:50:55.176] [error] Load library failed: libgomp.so.1: cannot open shared object file: No such file or directory ``` The error is caused by the lack of `libgomp.so.1`, a library that should be automatically installed on Ubuntu by default. To solve this, you must install the `libgomp.so.1` library: ``` sudo apt-get update sudo apt-get install libgomp1 ``` If you're using CentOS, you can use: ``` yum install libgomp ``` This issue was fixed in `version 0.2.2`. ## Failed to remove the default collection[​](https://docs.gaianet.ai/node-guide/troubleshooting#failed-to-remove-the-default-collection) ``` Failed to remove the default collection. {"status":{"error":"Service internal error: No such file or directory (os error 2)"},"time":0.050924542} ``` It typically indicates that the Qdrant instance was not shut down properly before you try to init it again with a new snapshot. The solution is to stop the GaiaNet node first: ``` gaianet stop ``` Alternatively, you could mannually kill the processes from the terminal or in the OS's Actvity Monitor: ``` sudo pkill -9 qdrant sudo pkill -9 wasmedge sudo pkill -9 frpc ``` Then you can run `gaianet init` and then `gaianet start` again. ## File I/O error[​](https://docs.gaianet.ai/node-guide/troubleshooting#file-io-error) ``` * Import the Qdrant collection snapshot ... The process may take a few minutes. Please wait ... * [Error] Failed to recover from the collection snapshot. An error occurred processing field `snapshot`: File I/O error: Operation not permitted (os error 1) ``` It typically indicates that the Qdrant instance was not shut down properly before you try to init it again with a new snapshot. The solution is to stop the GaiaNet node first: ``` gaianet stop ``` Alternatively, you could mannually kill the processes from the terminal or in the OS's Actvity Monitor. ``` sudo pkill -9 qdrant sudo pkill -9 wasmedge sudo pkill -9 frpc ``` Then you can run `gaianet init` and then `gaianet start` again. ## The "Failed to open the file" Error[​](https://docs.gaianet.ai/node-guide/troubleshooting#the-failed-to-open-the-file-error) ``` Warning: Failed to open the file Warning: https://huggingface.co/datasets/max-id/gaianet-qdrant-snapshot/resolve Warning: /main/consensus/consensus.snapshot: No such file or directory curl: (23) Failure writing output to destination ``` The reason for this type of error is a mis-configured `config.json` file. The solution is to delete the comments in `config.json` and re-run the `gaianet init` command. ## The "Too many open files" Error on macOS[​](https://docs.gaianet.ai/node-guide/troubleshooting#the-too-many-open-files-error-on-macos) When running `gaianet init` to initialize a new node on macOS, you may encounter an error related to snapshot recovery if your snapshot contains a large amount of text. The error message may be the following: ``` * [Error] Failed to recover from the collection snapshot. {"status":{"error":"Service internal error: Too many open files (os error 24)"},"time":1.574064833} * [Error] Failed to recover from the collection snapshot. {"status":{"error":"Service internal error: Too many open files (os error 24)"},"time":1.574064833} ``` This issue is caused by the default file descriptor (FD) limit on macOS, which is set to a relatively low value of 256. To resolve this issue, you can increase the default FD limit on your system. To do so, run the following command: ``` ulimit -n 10000 ``` This will temporarily set the FD limit to 10,000. Next, use `gaianet init` and `gaianet start` commands in the SAME terminal. ## Permission denied when use the installer script to install WasmEdge[​](https://docs.gaianet.ai/node-guide/troubleshooting#permission-denied-when-use-the-installer-script-to-install-wasmedge) When running `curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash` to install GaiaNet node software, you may meet the permisson denied error especially installing the WasmEdge runtime.
This error is caused by the lack of `/tmp` write permission. You can use `--tmpdir` to specify where you want to install the WasmEdge runtime. Please note, you will need to have written permission to the `` folder. ``` curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash -s -- --tmpdir YOUR_PATH ``` This problem is fixed in `version 0.2.3`. # Apply for a bounty As a developer, your input is crucial for driving innovation. Apply for a bounty to be an integral part of the Gaia ecosystem while also receiving compensation for your conrtribution ### Living Knowledge Systems Hackathon Through September 19, 2024 you have the ability to participate in our Living Knowledge Systems Hackathon with the chance of winning up to 15,000 USDT. [Participate Here](https://www.hackquest.io/en/hackathon/explore/Living-Knowledge-Systems-Decentralized-AI-Hackathon) ### Gaia Integration Bounty Submission Did you build a functioning dApp or integration with Gaia? How about deployed a node with a unique dataset? If so, enter your submission for a bounty and your chance to win up to 800 USDC. [Submit Here](https://docs.google.com/forms/d/e/1FAIpQLSdwvbKGAWspvDqilXnrnuWt51zZUbYL9t4wj1NSwGx2uQhVcg/viewform) ### Dework Open Tasks Get yourself assigned to an open task like building your own AI Agent or creating a Hong Kong Tour Guide GPT. [Click Here](https://app.dework.xyz/gaia/main-space-84384) # Guides and Tutorials As a developer, you're probably wondering what things you can create with your nodes. Use the guides and tutorials below to show you the capabilities. # Creating a Formula 1 Chatbot Use this tutorial to learn how to build a chatbot customized with Formula 1 data. ## Overview This guide will help you develop a specialized AI agent using Gaia. In this example, we are building a chatbot specializing in Formula 1 data that will respond to inquiries around its history, competitions, and regulations. This guide will show you how to set up a Gaia node, build a knowledge base, and launch a customized LLM chatbot. By the end of this guide, we will have a live chatbot that will answer F1 inquiries. ## What is Gaia? Gaia is a decentralized computing infrastructure that enables everyone to create, deploy, scale, and monetize their own AI agents that reflect their styles, values, knowledge, and expertise. It allows individuals and businesses to create AI agents. Each GaiaNet node provides: * a web-based chatbot UI * an OpenAI compatible API ### **Installing a Gaia Node on your system** Before we begin building our F1 chatbot, we must first install a node on your system. A Gaia node can be installed on a variety of devices and operating systems. For more information, check out the [System Requirements.](https://docs.gaianet.ai/node-guide/system-requirements)
Let’s quickly get a node installed on your system. 1. Using your terminal, run this script to download the latest version of the GaiaNet node: ```bash curl -sSfL 'https://github.com/GaiaNet-AI/gaianet-node/releases/latest/download/install.sh' | bash` ```

Image displaying a successful node installation

* After you run the script, you will see the following in your terminal: * Node ID * A command that will make the GaiaNet CLI tool available within the shell * A command that will allow you to initialize the node. 2. Run the command that will make the CLI tool available, it will begin with `source`. 3. Initialize your node by using the `gaianet init` command. The CLI tool will help you download the models and recover the knowledge embeddings. 4. After you’ve initialized the node, start it by using the `gaianet start` command.

Image displaying a successful node initialization

Congrats! You’ve installed and started your GaiaNet node! Now that we have completed our initial step, we can start preparing our F1 chatbot. ## Building a Knowledge Base ### Preparing the F1 Data Our Gaia node is up and running, so now we need to prepare our F1 data. Data preparation takes the following steps: 1. Aggregating data sources 2. Creating a .txt file and adding data. 3. Segmenting the data For this tutorial, we will be using the following data sources to train our chatbot: * * * * {% hint style="info" %} Your .txt file must be structured with clear sections under 768 words. {% endhint %} #### **Example** The following example demonstrates the structure of the .txt file and how it should be formatted. If your file is under 768 words, then you do not need line breaks. If your file is over 768 words then you will need line breaks. {% code overflow="wrap" %} ``` What is Formula One or F1 or FIA World Championship? Formula One, commonly known as Formula 1 or F1, is the highest class of international racing for open-wheel single-seater formula racing cars sanctioned by the Fédération Internationale de l'Automobile (FIA). The FIA Formula One World Championship has been one of the world's premier forms of racing since its inaugural running in 1950. The word formula in the name refers to the set of rules all participants' cars must follow. A Formula One season consists of a series of races, known as Grands Prix. Grands Prix take place in multiple countries and continents on either purpose-built circuits or closed public roads. A point-system is used at Grands Prix to determine two annual World Championships: one for the drivers, and one for the constructors (the teams). What is Formula One or F1 or FIA World Championship? Each driver must hold a valid Super Licence, the highest class of racing licence the FIA issues, and the races must be held on grade one tracks, the highest grade rating the FIA issues for tracks. Formula One cars are the world's fastest regulated road-course racing cars, owing to very high cornering speeds achieved by generating large amounts of aerodynamic downforce. Much of this downforce is generated by front and rear wings, which have the side effect of causing severe turbulence behind each car. The turbulence reduces the downforce the cars following directly behind generate, making it hard to overtake. What is Formula One or F1 or FIA World Championship? Major changes made to the cars for the 2022 season have resulted in greater use of ground effect aerodynamics and modified wings to reduce the turbulence behind the cars, with the goal of making overtaking easier. The cars depend on electronics, aerodynamics, suspension, and tyres. Traction control, launch control, and automatic shifting, and other electronic driving aids were first banned in 1994. They were briefly reintroduced in 2001, and have more recently been banned since 2004 and 2008, respectively. With the average annual cost of running a team—designing, building, and maintaining cars, pay, transport—at approximately £220,000,000 (or $265,000,000), Formula One's financial and political battles are widely reported. What is Formula One or F1 or FIA World Championship? The Formula One Group is owned by Liberty Media, which acquired it in 2017 from private-equity firm CVC Capital Partners for £6.4 billion ($8 billion). ``` {% endcode %} ### Building your knowledge base and embedding model Now that the data has been aggregated, it will be converted into a vector database. For this tutorial, we will be using the GaiaNet tool that was developed to make vector collection snapshot files. This tool makes it easy for everyone to create their own knowledge base.

Image displaying GaiaNet web tool

{% embed url="" fullWidth="false" %} 1. First, you’ll upload the .txt file created earlier into the tool by either dragging the file or uploading it. 2. In the “snapshot\_name” section, provide a name for the snapshot. {% hint style="info" %} The snapshot name should not have any special characters or spaces {% endhint %} 3. Click “Make a RAG,” this process can take a few minutes depending on the size of your file. 4. After the RAG has been created, a JSON response will be generated and will look something like this: {% code overflow="wrap" %} ``` { "embedding": "https://huggingface.co/gaianet/nomic-embed-text-gguf/resolve/main/nomic-embed-text-v1.5.f16.gguf", "embedding_ctx_size": "8192", "embedding_batch_size": "8192", "snapshot": "https://huggingface.co/datasets/max-id/gaianet-qdrant-snapshot/resolve/main/formula1-b38b0f78-374b-44cc-a7ad-5157e7867760/formula1-b38b0f78-374b-44cc-a7ad-5157e7867760.snapshot" } ``` {% endcode %} Congrats, you’ve made your RAG and we will proceed to configuring your node! ### Configuring your GaiaNet node So far, we’ve installed a node on our system, built a knowledge base, and made a RAG for our Formula 1 data. We now have to configure our node to use our F1 knowledge base. 1. Update the LLM model, we will use a model with better performance than the default. Run this code to update with [Meta Llama 3.1-8B](https://huggingface.co/gaianet/Meta-Llama-3.1-8B-Instruct-GGUF): {% code overflow="wrap" %} ``` gaianet config \ --snapshot https://huggingface.co/datasets/max-id/gaianet-qdrant-snapshot/resolve/main/formula1-b38b0f78-374b-44cc-a7ad-5157e7867760/formula1-b38b0f78-374b-44cc-a7ad-5157e7867760.snapshot \ --embedding-url https://huggingface.co/gaianet/nomic-embed-text-gguf/resolve/main/nomic-embed-text-v1.5.f16.gguf \ --embedding-ctx-size 8192 \ --chat-url https://huggingface.co/gaianet/Meta-Llama-3.1-8B-Instruct-GGUF/resolve/main/Meta-Llama-3.1-8B-Instruct-Q5_K_M.gguf \ --chat-ctx-size 8192 \ --prompt-template llama-3-chat \ --system-prompt "You are an expert in Formula 1, with deep knowledge of race history, driver statistics and team strategies. Provide brief and accurate answers to questions about F1. Pay special attention to formatting-use bullet points, bolding and line breaks to make the text easier to read." \ --rag-prompt "The following text is the context for the user question. \n----------------\n" ``` {% endcode %} 2. Update the configuration changes: ``` gaianet init gaianet start ``` Now that your node is restarted and configured with the Formula 1 data, the fun now begins! ### Testing your F1 Agent Use the node URL that was generated when your node was first created, to access the agent and test it out.

Voila! You now have a Gaia node that has been configured to be a Formula 1 chatbot!

# Case Studies https\://www\.gaianet.ai/agents \[Airtable/GoogleSpreadsheet] # GaiaNet Token You're successfully running a GaiaNet node on your machine, now it's time to join the protocol network to receive rewards for sharing your computing power with the world! ### GaiaNet Token The GaiaNet token is a utility token designed to facilitate transactions, support governance, and foster trust in the network. It serves three primary purposes: * As a DAO governance token, holders can participate in setting the rules of the network. * As a staking token, holders vouch for domain operators’ trustworthiness. Stakers get a cut from the domain operator’s service revenue. But they could also be slashed if the domain operator misbehave, such as spreading misinformation or providing unreliable services. * As a payment token, the GaiaNet token could be deposited into the domain’s escrow contract and be used to pay for services over time. The payment utility of the GaiaNet token is designed to balance the network supply and demand. The value of the GaiaNet token asset is determined at the time when it enters or leaves the escrow smart contract based on real-time exchange rates. Service consumers could lock in savings from the potential appreciation of the token. For example, if a user deposits $100 worth of GaiaNet tokens into the contract, and when the domain and nodes get paid, the token value has gone up to $110, he would have received $110 worth of agent services. Conversely, if the token price drops, the service providers (domains and nodes) now have an opportunity to “mine” the tokens on the cheap. If the $100 initial tokens is only worth $90 now, service providers will get more tokens for each unit of electricity and compute they provide. That incentivizes more nodes to join the network and speculate on a later rise in token value. # Mission, Values & Goals We aim to revolutionize the user experience with AI chatbots, seamlessly introducing transformative changes while preserving the current intuitive technology and satisfaction existing in the Web2 era. ### Mission Our focus is on building a robust decentralized AI network alongside an ecosystem that makes our vision a reality. We are committed to developing innovative technologies, fostering collaboration among developers and users, and advocating for the principles of democratisation and decentralization in AI. ### Values * We believe information AI’s access should be democratized and censorship-resistant * We believe in transparency and security * We believe decentralization shouldn’t mean limitation * We support user control and data privacy * We are user-first * We are committed to making our products with integrity ### Goals We envision a future where AI technologies are transparent, accessible, and beneficial to all, driving innovation and progress across industries. We see a future for decentralized AI where algorithms and search engines do not choose what information people see. In this future, the computing power in our personally owned devices will replace the company-owned central servers, with the processing power that enables decentralized AI to act for and with us, and so much more. # Network Components Our network components consist of decentralized nodes that host and run AI agents governed by the GaiaNet protocol. The nodes operate independently and contribute to the network’s processing power while using secure protocols to ensure privacy and security. The GaiaNet token also plays a key role in both incentivizing node operators and facilitating community governance. Our network’s decentralized architecture ensures scalability and censorship-resistance. \
# Governance Process The GaiaNet DAO is established to govern the GaiaNet network in collaboration with all GaiaNet token holders. At Gaia, our community is not just a group of users; they are co-creators of the ecosystem. We empower our community to shape the future of AI-driven solutions by providing them with the tools, resources, and support needed to build, deploy, and scale their AI agents. Through initiatives like our global hackathon series, open-source contributions, and governance participation, community members have the opportunity to influence the direction of Gaia’s development. This decentralized approach to innovation ensures that the platform evolves in a way that reflects the diverse needs and values of its users, creating a more inclusive and adaptable ecosystem in their parts of the world. # Privacy & Security ### Decentralization Focus Decentralization is a crucial component to GaiaNet because it aligns with the platform's core values of privacy, security, and censorship resistance. Through distributing AI agents across a network of independent nodes, GaiaNet eliminates reliance on centralized entities, reducing the risk of data breaches, control by a single party, and censorship. This structure empowers users, ensures transparency, and promotes a more equitable ecosystem that gives community members a direct role in governance and decision-making. ### Privacy Measures End-to-end encryption, to safeguard data during transmission and decentralized authentication mechanisms that prevent single points of failure are some of the privacy measures used by GaiaNet. The network's decentralized nature also enhances privacy by distributing data processing across multiple nodes thereby reducing the risk of centralized data breaches. Additionally, our design prioritizes censorship resistance to ensure that users have control over their data without external interference. \ \ \