Hypermode

https://docs.hypermode.com
Admin
Hypermode is an AI agent development platform for rapidly building, experimenting with, and...
Tokens:634,644
Snippets:3,033
Trust Score:8.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install Badger Go Library

Source: https://docs.hypermode.com/badger/quickstart

Installs the Badger database library using the Go module system. Ensure you have Go v1.23 or higher installed.

```sh
go get github.com/dgraph-io/badger/v4
```

--------------------------------

### Install Badger CLI Utility

Source: https://docs.hypermode.com/badger/quickstart

Installs the Badger command-line utility to your Go binary path. This utility can be used for database management.

```sh
go install github.com/dgraph-io/badger/v4/badger@latest
```

--------------------------------

### Manually Manage BadgerDB Transactions

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates how to manually start, defer discard, set values, and commit a writable BadgerDB transaction. This approach is useful when the automatic transaction management of DB.View() and DB.Update() is not suitable.

```go
txn := db.NewTransaction(true)
defer txn.Discard()

// Use the transaction...
err := txn.Set([]byte("answer"), []byte("42"))
if err != nil {
    return err
}

// Commit the transaction and check for error.
if err := txn.Commit(); err != nil {
    return err
}
```

--------------------------------

### Configure Badger Encryption with Cache

Source: https://docs.hypermode.com/badger/quickstart

Sets up Badger for encrypted mode, which requires configuring the index cache size for optimal performance. This example sets a 100MB cache.

```go
opts.IndexCache = 100 << 20 // 100 mb or some other size based on the amount of data
```

--------------------------------

### Dgraph Alpha Startup Examples

Source: https://docs.hypermode.com/dgraph/self-managed/cluster-types

Examples of commands to start Dgraph Alpha nodes. These commands specify the Alpha's network address and the address of the Dgraph Zero instance it should connect to. The number of replicas is determined by Dgraph Zero's --replicas flag.

```bash
dgraph alpha --my=alpha1:7080 --zero=zero1:5080
```

```bash
dgraph alpha --my=alpha2:7080 --zero=zero1:5080
```

```bash
dgraph alpha --my=alpha3:7080 --zero=zero1:5080
```

--------------------------------

### Install Dgraph Go Client

Source: https://docs.hypermode.com/dgraph/sdks/go

Instructions for installing the Dgraph Go client using go get. Requires Go 1.23 or later and sets the GO111MODULE environment variable.

```shell
export GO111MODULE=on
go get -u -v github.com/dgraph-io/dgo/v240
```

--------------------------------

### Merge operations in Go

Source: https://docs.hypermode.com/badger/quickstart

Defines a MergeFunc and shows how to register it via DB.GetMergeOperator, add values with MergeOperator.Add, and retrieve the cumulative result with Get. Demonstrates both byte-slice append and uint64 counter merge, including helper conversions. Dependencies: github.com/dgraph-io/badger/v4.

```go
// Merge function to append one byte slice to another
func add(originalValue, newValue []byte) []byte {
  return append(originalValue, newValue...)
}

// Usage:
key := []byte("merge")

m := db.GetMergeOperator(key, add, 200*time.Millisecond)
defer m.Stop()

m.Add([]byte("A"))
m.Add([]byte("B"))
m.Add([]byte("C"))

res, _ := m.Get() // res should have value ABC encoded

// Helpers for uint64 merge
func uint64ToBytes(i uint64) []byte {
  var buf [8]byte
  binary.BigEndian.PutUint64(buf[:], i)
  return buf[:]
}

func bytesToUint64(b []byte) uint64 {
  return binary.BigEndian.Uint64(b)
}

// Merge function to add two uint64 numbers
func add(existing, new []byte) []byte {
  return uint64ToBytes(bytesToUint64(existing) + bytesToUint64(new))
}

// Usage:
key2 := []byte("merge")

m2 := db.GetMergeOperator(key2, add, 200*time.Millisecond)
defer m2.Stop()

m2.Add(uint64ToBytes(1))
m2.Add(uint64ToBytes(2))
m2.Add(uint64ToBytes(3))

res2, _ := m2.Get() // res2 should have value 6 encoded

```

--------------------------------

### Generate Monotonically Increasing Integers with BadgerDB

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates how to obtain a thread-safe `Sequence` object from BadgerDB using `DB.GetSequence()` to generate unique, monotonically increasing integers. It includes an example of iterating to get the next number and the importance of calling `Release()`.

```go
seq, err := db.GetSequence(key, 1000)
defer seq.Release()
for {
  num, err := seq.Next()
  // Use num...
}
```

--------------------------------

### Open Badger Database

Source: https://docs.hypermode.com/badger/quickstart

Opens a Badger database instance. This Go code snippet demonstrates how to initialize a database, specifying the directory for data storage. It includes error handling and ensures the database is closed when the function exits.

```go
package main

import (
  "log"

  badger "github.com/dgraph-io/badger/v4"
)

func main() {
  // Open the Badger database located in the /tmp/badger directory.
  // It is created if it doesn't exist.
  db, err := badger.Open(badger.DefaultOptions("/tmp/badger"))
  if err != nil {
    log.Fatal(err)
  }

  defer db.Close()

  // your code here
}
```

--------------------------------

### Start Dgraph Zero with Vault configuration example (shell)

Source: https://docs.hypermode.com/dgraph/enterprise/encryption-at-rest

Shows how to start a Dgraph Zero node as part of a setup where the encryption key is stored in HashiCorp Vault. The command runs in a separate terminal; subsequent Alpha nodes would be started with appropriate --vault flags. Useful for testing Vault‑based key management.

```sh
## Start Dgraph Zero in different terminal tab or window
 dgraph zero --my=localhost:5080 --replicas 1 --raft "idx=1"
```

--------------------------------

### Get Value by Key in BadgerDB Transaction

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates retrieving a value associated with a key within a BadgerDB transaction using `Txn.Get()`. It highlights the correct way to access the value using `item.Value()` and the importance of copying the value if needed outside the transaction scope.

```go
err := db.View(func(txn *badger.Txn) error {
  item, err := txn.Get([]byte("answer"))
  handle(err)

  var valNot, valCopy []byte
  err := item.Value(func(val []byte) error {
    // This func with val would only be called if item.Value encounters no error.

    // Accessing val here is valid.
    fmt.Printf("The answer is: %s\n", val)

    // Copying or parsing val is valid.
    valCopy = append([]byte{}, val...)

    // Assigning val slice to another variable is NOT OK.
    valNot = val // Do not do this.
    return nil
  })
  handle(err)

  // DO NOT access val here. It is the most common cause of bugs.
  fmt.Printf("NEVER do this. %s\n", valNot)

  // You must copy it to use it outside item.Value(...).
  fmt.Printf("The answer is: %s\n", valCopy)

  // Alternatively, you could also use item.ValueCopy().
  valCopy, err = item.ValueCopy(nil)
  handle(err)
  fmt.Printf("The answer is: %s\n", valCopy)

  return nil
})
```

--------------------------------

### Perform Key-Only Iteration in Go with BadgerDB

Source: https://docs.hypermode.com/badger/quickstart

Shows how to perform key-only iteration in Go using BadgerDB, which significantly improves performance by accessing only the LSM-tree. It disables value prefetching to optimize reads.

```go
err := db.View(func(txn *badger.Txn) error {
  opts := badger.DefaultIteratorOptions
  opts.PrefetchValues = false
  it := txn.NewIterator(opts)
  defer it.Close()
  for it.Rewind(); it.Valid(); it.Next() {
    item := it.Item()
    k := item.Key()
    fmt.Printf("key=%s\n", k)
  }
  return nil
})
```

--------------------------------

### Set Key/Value Pair using BadgerDB Entry

Source: https://docs.hypermode.com/badger/quickstart

Illustrates setting a key/value pair by first creating an `Entry` object and then using `Txn.SetEntry()`. This method allows for setting additional entry properties before saving.

```go
err := db.Update(func(txn *badger.Txn) error {
  e := badger.NewEntry([]byte("answer"), []byte("42"))
  err := txn.SetEntry(e)
  return err
})
```

--------------------------------

### Running Dgraph with Custom Tokenizers

Source: https://docs.hypermode.com/dgraph/dql/indexing-custom-tokenizers

Example command showing how to start the Dgraph server and load custom tokenizer plugins using the `--custom_tokenizers` flag. The flag accepts a comma-separated list of `.so` plugin files.

```sh
dgraph ...other-args... --custom_tokenizers=plugin1.so,plugin2.so
```

--------------------------------

### Implement Pagination with Prefix Scans in Go

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates how to perform prefix scans for pagination in Go using BadgerDB. It uses a cursor to resume iteration and a limit to control the number of results. The prefix scan is configured to sort by timestamp.

```go
reversedTimestamp := math.MaxInt64-time.Now().Unix()

// startCursor may look like 'feed:tQpnEDVRoCxTFQDvyQEzdo:1733127486'.
// A prefix scan with this cursor locates the specific key where
// the previous iteration stopped.
err = db.badger.View(func(txn *badger.Txn) error {
        it := txn.NewIterator(opts)
        defer it.Close()

        // Prefix example 'feed:tQpnEDVRoCxTFQDvyQEzdo'
        // if no cursor provided prefix scan starts from the beginning
        p := prefix
        if startCursor != nil {
             p = startCursor
        }
        iterNum := 0 // Tracks the number of iterations to enforce the limit.
        for it.Seek(p); it.ValidForPrefix(p); it.Next() {
            // The method it.ValidForPrefix ensures that iteration continues
            // as long as keys match the prefix.
            // For example, if p = 'feed:tQpnEDVRoCxTFQDvyQEzdo:1733127486',
            // it matches keys like
            // 'feed:tQpnEDVRoCxTFQDvyQEzdo:1733127889:pprRrNL2WP4yfVXsSNBSx6'.

            // Once the starting point for iteration is found, revert the prefix
            // back to 'feed:tQpnEDVRoCxTFQDvyQEzdo' to continue iterating sequentially.
            // Otherwise, iteration would stop after a single prefix-key match.
            p = prefix

            item := it.Item()
            key := string(item.Key())

            if iterNum > limit { // Limit reached.
                nextCursor = key // Save the next cursor for future iterations.
                return nil
            }
            iterNum++ // Increment iteration count.

            err := item.Value(func(v []byte) error {
                fmt.Printf("key=%s, value=%s\n", k, v)
                return nil
            })
            if err != nil {
                return err
            }
        }
        // If the number of iterations is less than the limit,
        // it means there are no more items for the prefix.
        if iterNum < limit {
            nextCursor = ""
        }
        return nil
    })
return nextCursor, err
```

--------------------------------

### Using BadgerDB Stream for Key-Value Iteration

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates how to configure and run BadgerDB's Stream framework to efficiently iterate over database entries. It covers setting concurrency, filtering keys, transforming values, and serializing results. This is useful for bulk data processing and backups.

```go
stream := db.NewStream()
// db.NewStreamAt(readTs) for managed mode.

// -- Optional settings
stream.NumGo = 16                     // Set number of goroutines to use for iteration.
stream.Prefix = []byte("some-prefix") // Leave nil for iteration over the whole DB.
stream.LogPrefix = "Badger.Streaming" // For identifying stream logs. Outputs to Logger.

// ChooseKey is called concurrently for every key. If left nil, assumes true by default.
stream.ChooseKey = func(item *badger.Item) bool {
  return bytes.HasSuffix(item.Key(), []byte("er"))
}

// KeyToList is called concurrently for chosen keys. This can be used to convert
// Badger data into custom key-values. If nil, uses stream.ToList, a default
// implementation, which picks all valid key-values.
stream.KeyToList = nil

// -- End of optional settings.

// Send is called serially, while Stream.Orchestrate is running.
stream.Send = func(list *pb.KVList) error {
  return proto.MarshalText(w, list) // Write to w.
}

// Run the stream
if err := stream.Orchestrate(context.Background()); err != nil {
  return err
}
// Done.
```

--------------------------------

### Iteration and prefix scans in Go

Source: https://docs.hypermode.com/badger/quickstart

Demonstrates creating an iterator with Txn.NewIterator, iterating in byte-wise lexicographical order, and reading key/value pairs. Also shows prefix scans by combining Seek with ValidForPrefix. Configure PrefetchSize to tune value prefetching; avoid setting it higher than GOMAXPROCS.

```go
err := db.View(func(txn *badger.Txn) error {
  opts := badger.DefaultIteratorOptions
  opts.PrefetchSize = 10
  it := txn.NewIterator(opts)
  defer it.Close()
  for it.Rewind(); it.Valid(); it.Next() {
    item := it.Item()
    k := item.Key()
    err := item.Value(func(v []byte) error {
      fmt.Printf("key=%s, value=%s\n", k, v)
      return nil
    })
    if err != nil {
      return err
    }
  }
  return nil
})

// Prefix scans
db.View(func(txn *badger.Txn) error {
  it := txn.NewIterator(badger.DefaultIteratorOptions)
  defer it.Close()
  prefix := []byte("1234")
  for it.Seek(prefix); it.ValidForPrefix(prefix); it.Next() {
    item := it.Item()
    k := item.Key()
    err := item.Value(func(v []byte) error {
      fmt.Printf("key=%s, value=%s\n", k, v)
      return nil
    })
    if err != nil {
      return err
    }
  }
  return nil
})

```

--------------------------------

### Querying Nodes Using UIDs

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

Demonstrates how to query nodes by their UIDs using the `uid` function. This includes an example of how to first retrieve UIDs and then use them to query specific nodes.

```APIDOC
## Querying Nodes by UID

This section details how to use the `uid` function to query specific nodes within the database.

### Overview
The `uid` function accepts one or more UIDs as arguments and returns the corresponding nodes. It's important to note that the function returns the UIDs provided, regardless of whether they exist in the database. However, requested predicates are only returned if both the UIDs and their predicates exist.

### Example 1: Retrieving UIDs
This query retrieves UIDs, names, and ages for all people nodes that have a name.

```graphql
{
  people(func: has(name)) {
    uid
    name
    age
  }
}
```

*After running this query, copy the UID of the desired node (e.g., Michael's node) from the results.*

### Example 2: Querying a Specific Node Using UID
Replace `MICHAELS_UID` with the actual UID copied from the previous query result to retrieve the specific node's details.

```graphql
{
    find_using_uid(func: uid(MICHAELS_UID)){
        uid
        name
        age
    }
}
```

*Note: The UID `0x8` shown in the accompanying images is an example; your actual UID may differ.*

### Method
POST (typically used for GraphQL queries)

### Endpoint
`/graphql` (or your specific GraphQL endpoint)

### Parameters
#### Query Parameters
None

#### Request Body
```json
{
  "query": "{ people(func: has(name)) { uid name age } }"
}
```

### Response
#### Success Response (200)
Returns a JSON object containing the queried data.

#### Response Example (for Example 1)
```json
{
  "data": {
    "people": [
      {
        "uid": "0x1",
        "name": "Michael",
        "age": 30
      }
    ]
  }
}
```

#### Response Example (for Example 2, assuming `MICHAELS_UID` is `0x1`)
```json
{
  "data": {
    "find_using_uid": [
      {
        "uid": "0x1",
        "name": "Michael",
        "age": 30
      }
    ]
  }
}
```
```

--------------------------------

### Tool Sequencing Instructions Example in Text

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-16

This example provides sequential steps for handling complex workflows with tools. It emphasizes gathering information first, confirming actions, and reporting progress. Applicable to agent prompts for task management; no dependencies, but assumes tool availability and may require user confirmation for reliability.

```text
For complex workflows:
1. Gather all necessary information before taking actions
2. Confirm destructive actions (deleting, sending emails) with the user
3. Use the most reliable tool first, then fall back to alternatives
4. Report progress after each major tool usage
```

--------------------------------

### Dgraph client usage example in Go

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-22

Demonstrates how to initialize and use the news graph client for local development and production environments, including connection testing and various query operations.

```go
func ExampleUsage() {
    // Local development
    localAgent, err := NewNewsGraphClient("dgraph://localhost:9080")
    if err != nil {
        log.Fatal("Failed to create local client:", err)
    }

    // Production with SSL
    prodAgent, err := NewNewsGraphClient("dgraph://dgraph.example.com:443?ssl=true")
    if err != nil {
        log.Fatal("Failed to create production client:", err)
    }

    // Test connections
    fmt.Println("Local connection:", localAgent.TestConnection())
    fmt.Println("Production connection:", prodAgent.TestConnection())

    // Use the agent
    recentArticles, err := localAgent.GetRecentArticles(7, 5)
    if err != nil {
        log.Printf("Error getting recent articles: %v", err)
    } else {
        fmt.Printf("Recent articles: %+v\n", recentArticles)
    }

    // Search by topic
    techArticles, err := localAgent.SearchArticlesByTopic("technology", 10)
    if err != nil {
        log.Printf("Error searching by topic: %v", err)
    } else {
        fmt.Printf("Tech articles: %+v\n", techArticles)
    }

    // Get topic statistics
    topicStats, err := localAgent.GetTopicStatistics()
    if err != nil {
        log.Printf("Error getting topic statistics: %v", err)
    } else {
        fmt.Printf("Topic statistics: %+v\n", topicStats)
    }
}
```

```go
func main() {
    ExampleUsage()
}
```

--------------------------------

### Perform Read-Write Transaction in Badger

Source: https://docs.hypermode.com/badger/quickstart

Starts a read-write transaction using the `DB.Update()` method in Badger. This allows all database operations within the provided closure. It includes basic error handling for `ErrConflict` and `ErrTxnTooBig`.

```go
err := db.Update(func(txn *badger.Txn) error {
  // Your code here…
  return nil
})
```

```go
updates := make(map[string]string)
updates["key1"] = "value1"
updates["key2"] = "value2"

txn := db.NewTransaction(true)
for k,v := range updates {
  if err := txn.Set([]byte(k),[]byte(v)); err == badger.ErrTxnTooBig {
    _ = txn.Commit()
    txn = db.NewTransaction(true)
    _ = txn.Set([]byte(k),[]byte(v))
  }
}
_ = txn.Commit()
```

--------------------------------

### Retrieve all authors and ratings in DQL

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/types-and-operations

This DQL query fetches all nodes containing the author_name predicate in a Dgraph database. It outputs the uid, author_name, and rating for each author. Assumes Dgraph setup with these predicates defined.

```dql
{
  authors_and_ratings(func: has(author_name)) {
    uid
    author_name
    rating
  }
}
```

--------------------------------

### Optimized Tool Usage Guidelines Example in Text

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-16

An enhanced prompt with detailed guidelines for specific tools like GitHub and Google Sheets. It includes usage rules and confirmation requirements. Useful for agent prompts in development and communication contexts; assumes tool access and focuses on explanation, with potential limitations if tools change.

```text
Tool Usage Guidelines:
- GitHub: Use for code review, repository management, and development workflows
- Google Sheets: Use for data analysis, reporting, and collaborative documentation
- Slack: Use for team communications and status updates (always prefix with "Agent:")
- Gmail: Use for external communications and formal correspondence

Always explain why you're choosing a specific tool and ask for confirmation before taking actions that affect external systems.
```

--------------------------------

### Create Edge Between Nodes with JSON

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

Establishes a relationship edge between two existing nodes in Dgraph using JSON mutations. Uses the 'set' operation with UIDs to create directed edges. Requires UIDs for both source and target nodes. In this example, creates a 'follows' relationship from Leyla to Michael.

```json
{
  "set": [
    {
      "uid": "LEYLAS_UID",
      "follows": {
        "uid": "MICHAELS_UID"
      }
    }
  ]
}
```

--------------------------------

### Tool Selection Guidance Example in Text

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-16

This snippet outlines decision-making criteria for choosing tools based on task types. It specifies tools like Google Sheets for data analysis and Slack for communication, while requiring users to be informed of the reasoning. No dependencies or external inputs are needed; it's a guidance template applicable to general agent prompts with limitations in specificity for custom tools.

```text
When deciding which tools to use:
1. For data analysis tasks, prioritize Google Sheets for structured data
2. For research tasks, use web search first, then supplement with specific databases
3. For communication tasks, choose Slack for internal team updates, Gmail for external
4. Always explain your tool selection reasoning to the user
```

--------------------------------

### JSON Configuration Examples (Kebab-case and Snake_case)

Source: https://docs.hypermode.com/dgraph/self-managed/config

This snippet shows how to define configuration options in JSON format. It includes examples for both kebab-case and snake_case naming conventions, illustrating settings for badger, trace, security, and TLS.

```json
{
  "<superflag-name>": {
    "option-a": "value",
    "option-b": "value"
  }
}
```

```json
{
  "badger": { "compression": "zstd:1" },
  "trace": { "jaeger": "http://jaeger:14268" },
  "security": { "whitelist": "10.0.0.0/8,172.0.0.0/8,192.168.0.0/16" },
  "tls": {
    "ca-cert": "/dgraph/tls/ca.crt",
    "client-auth-type": "REQUIREANDVERIFY",
    "server-cert": "/dgraph/tls/node.crt",
    "server-key": "/dgraph/tls/node.key",
    "use-system-ca": true,
    "internal-port": true,
    "client-cert": "/dgraph/tls/client.dgraphuser.crt",
    "client-key": "/dgraph/tls/client.dgraphuser.key"
  }
}
```

```json
{
  "badger": { "compression": "zstd:1" },
  "trace": { "jaeger": "http://jaeger:14268" },
  "security": { "whitelist": "10.0.0.0/8,172.0.0.0/8,192.168.0.0/16" },
  "tls": {
    "ca_cert": "/dgraph/tls/ca.crt",
    "client_auth_type": "REQUIREANDVERIFY",
    "server_cert": "/dgraph/tls/node.crt",
    "server_key": "/dgraph/tls/node.key",
    "use_system_ca": true,
    "internal_port": true,
    "client_cert": "/dgraph/tls/client.dgraphuser.crt",
    "client_key": "/dgraph/tls/client.dgraphuser.key"
  }
}
```

--------------------------------

### POST /graphql

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

Performs recursive traversal of the graph starting from a specific node. The recurse directive allows multi-level deep traversals with a specified maximum depth.

```APIDOC
## POST /graphql

### Description
Performs recursive traversal of the graph starting from a specific node. The recurse directive allows multi-level deep traversals with a specified maximum depth.

### Method
POST

### Endpoint
/graphql

### Parameters
#### Query Parameters
- **depth** (integer) - Required - Maximum depth the traversal should consider

#### Request Body
- **func** (string) - Required - Function to identify the starting node (e.g., uid())
- **fields** (array) - Required - Fields to retrieve during traversal

### Request Example
{
  "query": "{\n  find_follower(func: uid(0x1)) @recurse(depth: 4) {\n    name\n    age\n    follows\n  }\n}"
}

### Response
#### Success Response (200)
- **data** (object) - Contains the recursively traversed graph data

#### Response Example
{
  "data": {
    "find_follower": [
      {
        "name": "Michael",
        "age": 35,
        "follows": {
          "name": "Pawan",
          "age": 28
        }
      }
    ]
  }
}
```

--------------------------------

### YAML Configuration Examples (Kebab-case and Snake_case)

Source: https://docs.hypermode.com/dgraph/self-managed/config

This snippet demonstrates configuration options in YAML format, showcasing both kebab-case and snake_case naming conventions. It covers settings for badger, trace, security, and TLS, providing a clear structure for managing application parameters.

```yaml
<superflag-name>:
  option-a: value
  option-b: value
```

```yaml
badger:
  compression: zstd:1
trace:
  jaeger: http://jaeger:14268
security:
  whitelist: 10.0.0.0/8,172.0.0.0/8,192.168.0.0/16
tls:
  ca-cert: /dgraph/tls/ca.crt
  client-auth-type: REQUIREANDVERIFY
  server-cert: /dgraph/tls/node.crt
  server-key: /dgraph/tls/node.key
  use-system-ca: true
  internal-port: true
  client-cert: /dgraph/tls/client.dgraphuser.crt
  client-key: /dgraph/tls/client.dgraphuser.key
```

```yaml
badger:
  compression: zstd:1
trace:
  jaeger: http://jaeger:14268
security:
  whitelist: 10.0.0.0/8,172.0.0.0/8,192.168.0.0/16
tls:
  ca_cert: /dgraph/tls/ca.crt
  client_auth_type: REQUIREANDVERIFY
  server_cert: /dgraph/tls/node.crt
  server_key: /dgraph/tls/node.key
  use_system_ca: true
  internal_port: true
  client_cert: /dgraph/tls/client.dgraphuser.crt
  client_key: /dgraph/tls/client.dgraphuser.key
```

--------------------------------

### TTL and user metadata in Go

Source: https://docs.hypermode.com/badger/quickstart

Shows how to set optional TTL and user metadata on entries using Entry.WithTTL and Entry.WithMeta, and how to combine them before Txn.SetEntry. TTL causes keys to expire after the duration; user metadata stores a single byte per key for application-specific flags. Requires time package for TTL.

```go
err := db.Update(func(txn *badger.Txn) error {
  e := badger.NewEntry([]byte("answer"), []byte("42")).WithTTL(time.Hour)
  err := txn.SetEntry(e)
  return err
})

err := db.Update(func(txn *badger.Txn) error {
  e := badger.NewEntry([]byte("answer"), []byte("42")).WithMeta(byte(1))
  err := txn.SetEntry(e)
  return err
})

err := db.Update(func(txn *badger.Txn) error {
  e := badger.NewEntry([]byte("answer"), []byte("42")).WithMeta(byte(1)).WithTTL(time.Hour)
  err := txn.SetEntry(e)
  return err
})

```

--------------------------------

### Query Devrel Tags in Dgraph GraphQL

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/types-and-operations

This GraphQL query fetches the root node for the 'devrel' tag using the eq function after adding a hash index to the tag_name predicate. It requires Dgraph database setup and the tag_name predicate indexed. Input is the tag name string, output is the tag node with tag_name. Limitations include the need for proper indexing to avoid query failures.

```graphql
{
  devrel_tag(func: eq(tag_name,"devrel")) {
    tag_name
  }
}
```

--------------------------------

### Dgraph Recursive Traversal Query

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

Performs a recursive traversal of the graph starting from a specified node (UID) up to a defined depth. This allows for multi-level deep traversals of a subset of the graph. The `recurse` directive takes a `depth` parameter to control the traversal limit.

```graphql
{
  find_follower(func: uid(MICHAELS_UID)) @recurse(depth: 4) {
    name
    age
    follows
  }
}
```

--------------------------------

### Initialize Dgraph Client

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-22

Creates a new Dgraph client instance. It supports connection string-based initialization and defaults to a local Dgraph instance if no connection string is provided. Returns a pointer to the NewsGraphGo client or an error.

```Go
func NewNewsGraphClient(connectionString string) (*NewsGraphGo, error) {
    if connectionString == "" {
        connectionString = "dgraph://localhost:9080"
    }

    client, err := dgo.Open(connectionString)
    if err != nil {
        return nil, fmt.Errorf("failed to create Dgraph client: %v", err)
    }

    return &NewsGraphGo{
        client: client,
        connectionString: connectionString,
    }, nil
}
```

--------------------------------

### Search Documentation

Source: https://docs.hypermode.com/hypermode-docs-mcp

Searches across the Hypermode documentation to find relevant information, code examples, API references, and guides.

```APIDOC
## POST /search

### Description
Searches across the Hypermode documentation to find relevant information, code examples, API references, and guides.

### Method
POST

### Endpoint
/search

### Parameters
#### Query Parameters
- **query** (string) - Required - The search query to execute across the documentation

### Request Body
(Not applicable for this tool-like endpoint, parameters are typically passed as query parameters or within a structured tool call)

### Request Example
```json
{
  "name": "search",
  "arguments": {
    "query": "DQL query examples"
  }
}
```

### Response
#### Success Response (200)
- **results** (array) - An array of search results.
  - **title** (string) - The title of the documentation page.
  - **content** (string) - A brief description of the content.
  - **url** (string) - Direct link to the documentation page.
  - **snippet** (string) - Relevant text snippet from the documentation.

#### Response Example
```json
{
  "results": [
    {
      "title": "DQL Query Examples",
      "content": "Learn how to write DQL queries with filtering and range operations...",
      "url": "https://docs.hypermode.com/dgraph/dql/query",
      "snippet": "Use the @filter directive with ge() and le() functions to find users within age ranges..."
    }
  ]
}
```
```

--------------------------------

### Basic Tool Usage Prompt Before Optimization in Text

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-16

A minimal prompt allowing general tool usage for tasks. It serves as a baseline without specific guidelines. No inputs or dependencies; outputs are flexible, but lacks structure, limiting effectiveness in complex scenarios.

```text
You can use various tools to help users with their tasks.
```

--------------------------------

### Start Dgraph Zero and Alpha with ACL (Shell)

Source: https://docs.hypermode.com/dgraph/enterprise/access-control-lists

Demonstrates starting Dgraph Zero and Alpha nodes with ACL enabled using the Dgraph CLI. This includes creating the HMAC secret file and launching both nodes with appropriate configurations for a local cluster setup.

```shell
## Create ACL secret key file with 32 ASCII characters
echo '<SECRET KEY VALUE>' > hmac_secret_file

## Start Dgraph Zero in different terminal tab or window
dgraph zero --my=localhost:5080 --replicas 1 --raft idx=1

## Start Dgraph Alpha in different terminal tab or window
dgraph alpha --my=localhost:7080 --zero=localhost:5080 \
  --acl secret-file="./hmac_secret_file" \
  --security whitelist="10.0.0.0/8,172.0.0.0/8,192.168.0.0/16"
```

--------------------------------

### Delete Key in BadgerDB Transaction

Source: https://docs.hypermode.com/badger/quickstart

Shows how to delete a key and its associated value from a BadgerDB database using the `Txn.Delete()` method within a transaction.

```go
err := db.Update(func(txn *badger.Txn) error {
    return txn.Delete([]byte("keyToDelete"))
})
```

--------------------------------

### GraphQL Traversal Query for Followers

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

This GraphQL query demonstrates how to find users followed by a specific individual (Michael) and retrieve their name and age. It starts by identifying the root node using its UID, then traverses the 'follows' edge, and finally specifies the 'name' and 'age' predicates for the followed nodes.

```graphql
{\n    find_follower(func: uid(MICHAELS_UID)){\n        name\n        age\n        follows {\n          name\n          age\n        }\n    }\n}
```

--------------------------------

### Import Modus Go SDK Packages

Source: https://docs.hypermode.com/modus/sdk/go/overview

Demonstrates how to import specific Modus Go SDK packages based on their purpose. Ensure you have the correct package path for your project.

```go
import "github.com/hypermodeinc/modus/sdk/go/pkg/<package>"
```

--------------------------------

### POST /graphql/delete

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/basic-operations

Deletes predicates from a specific node using delete mutations. This mutation removes specified predicates from nodes identified by their UIDs.

```APIDOC
## POST /graphql/delete

### Description
Deletes predicates from a specific node using delete mutations. This mutation removes specified predicates from nodes identified by their UIDs.

### Method
POST

### Endpoint
/graphql/delete

### Parameters
#### Request Body
- **uid** (string) - Required - Unique identifier of the node
- **predicate_name** (string) - Required - Name of the predicate to delete
- **value** (string) - Optional - Specific value to delete (use * for all values)

### Request Example
{
  "query": "{\n  delete {\n    <0x1> <age> * .\n  }\n}"
}

### Response
#### Success Response (200)
- **data** (object) - Contains the result of the delete operation

#### Response Example
{
  "data": {
    "delete": {
      "numUids": 1
    }
  }
}
```

--------------------------------

### Initialize Dgraph Client

Source: https://docs.hypermode.com/agents/30-days-of-agents/day-22

Initializes the Dgraph client with a provided connection string. It handles opening the connection to the Dgraph instance. Dependencies include the 'dgraph' library. It takes a connection string as input and returns a Dgraph client instance.

```javascript
constructor(connectionString = "dgraph://<YOUR_DGRAPH_CONNECTION_STRING_HERE>") {
    /**
     * Initialize with Dgraph connection string.
     * Examples:
     * - dgraph://localhost:9080 (local development)
     * - dgraph://dgraph.example.com:443?ssl=true (production with SSL)
     */
    this.connectionString = connectionString
    this.client = this._createClient(connectionString)
  }

  _createClient(connectionString) {

    const dgraphClient = await dgraph.open(
    'dgraph://<YOUR_CONNECTION_STRING>',
  )
    return dgraphClient
  }
```

--------------------------------

### Insert Sample Twitter Data into Dgraph (JSON)

Source: https://docs.hypermode.com/dgraph/guides/get-started-with-dgraph/fuzzy-search

This JSON mutation example allows users to load sample tweet data into a Dgraph instance for fuzzy search and text querying tutorials. It requires an active Dgraph connection to execute the mutation in the mutation tab. The input is a JSON object with 'set' operations defining users, their authored tweets, tags, and mentions. Outputs include assigned UIDs for the inserted nodes, with no limitations on dataset size but assumes Dgraph schema supports the predicates.

```json
{
  "set": [
    {
      "user_handle": "hackintoshrao",
      "user_name": "Karthic Rao",
      "uid": "_:hackintoshrao",
      "authored": [
        {
          "tweet": "Test tweet for the fifth episode of getting started series with @dgraphlabs. Wait for the video of the fourth one by @francesc the coming Wednesday!\n#GraphDB #GraphQL",
          "tagged_with": [
            {
              "uid": "_:graphql",
              "hashtag": "GraphQL"
            },
            {
              "uid": "_:graphdb",
              "hashtag": "GraphDB"
            }
          ],
          "mentioned": [
            {
              "uid": "_:francesc"
            },
            {
              "uid": "_:dgraphlabs"
            }
          ]
        }
      ]
    },
    {
      "user_handle": "francesc",
      "user_name": "Francesc Campoy",
      "uid": "_:francesc",
      "authored": [
        {
          "tweet": "So many good talks at #graphqlconf, next year I'll make sure to be *at least* in the audience!\nAlso huge thanks to the live tweeting by @dgraphlabs for alleviating the FOMO😊\n#GraphDB ♥️ #GraphQL",
          "tagged_with": [
            {
              "uid": "_:graphql"
            },
            {
              "uid": "_:graphdb"
            },
            {
              "hashtag": "graphqlconf"
            }
          ],
          "mentioned": [
            {
              "uid": "_:dgraphlabs"
            }
          ]
        }
      ]
    },
    {
      "user_handle": "dgraphlabs",
      "user_name": "Dgraph Labs",
      "uid": "_:dgraphlabs",
      "authored": [
        {
          "tweet": "Let's Go and catch @francesc at @Gopherpalooza today, as he scans into Go source code by building its Graph in Dgraph!\nBe there, as he Goes through analyzing Go source code, using a Go program, that stores data in the GraphDB built in Go!\n#golang #GraphDB #Databases #Dgraph ",
          "tagged_with": [
            {

```
Tokens:
Raw