Raindrop

https://docs.liquidmetal.ai
Admin
Raindrop provides a developer platform to build and deploy scalable AI infrastructure and...
Tokens:164,098
Snippets:928
Trust Score:6.7
Update:11 months ago
Show doc for...
Tokens:
Raw
### Start Claude Code MCP Server

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Starts the Claude Code editor and connects to the Raindrop MCP server. This involves selecting the 'raindrop-mcp' server and authenticating.

```bash
/mcp
```

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

### Install Raindrop CLI

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Installs the Raindrop command-line interface globally using npm. This tool is essential for managing Raindrop services and MCP integrations.

```bash
npm install -g @liquidmetal-ai/raindrop
```

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

### Start Gemini CLI and Authenticate MCP

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Starts or restarts the Gemini CLI and then authenticates with the raindrop-mcp server. It also includes a command to verify the MCP server is listed.

```bash
gemini
```

```bash
/mcp auth raindrop-mcp
```

```bash
/mcp list
```

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

### Install Claude Code CLI

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Installs the Claude Code command-line interface globally using npm. This is a prerequisite for integrating with the Raindrop MCP server.

```bash
npm install -g @anthropic-ai/claude-code
```

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

### CLI Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use the command-line interface to query a document.

```APIDOC
## CLI Example

### Description
Example of how to use the command-line interface to query a document.

### Code
```bash
npx raindrop query document "What are the key points in this document?" \
  -b my-bucket \
  --object-id document.pdf
```
```

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

### Start New Raindrop Application (Gemini CLI)

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Initiates the creation of a new Raindrop application using Gemini CLI. This can be done via a slash command or a direct MCP tool call.

```bash
/new-raindrop-app
```

```text
Use the raindrop-mcp login tool to start a new application development session.
```

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

### Go Client Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use the Go client to query a document.

```APIDOC
## Go Client Example

### Description
Example of how to use the Go client to query a document.

### Code
```go
package main

import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
)

func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  response, err := client.Query.DocumentQuery(context.TODO(), raindrop.QueryDocumentQueryParams{
    BucketLocation: raindrop.BucketLocatorParam{Bucket: raindrop.LiquidmetalV1alpha1BucketNameParam{Name: "my-bucket", ApplicationName: raindrop.String("my-app"), Version: raindrop.String("01jtryx2f2f61ryk06vd8mr91p")}},
    Input: "What are the key points in this document?",
    ObjectID: "document.pdf",
    RequestID: "<YOUR-REQUEST-ID>",
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.Answer)
}
```
```

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

### Java Client Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use the Java client to query a document.

```APIDOC
## Java Client Example

### Description
Example of how to use the Java client to query a document.

### Code
```java
package com.raindrop.api.example;

import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.models.query.BucketLocator;
import com.raindrop.api.models.query.LiquidmetalV1alpha1BucketName;
import com.raindrop.api.models.query.QueryDocumentQueryParams;
import com.raindrop.api.models.query.QueryDocumentQueryResponse;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();

        QueryDocumentQueryParams params = QueryDocumentQueryParams.builder()
            .bucketLocation(BucketLocator.Bucket.builder()
                .bucket(LiquidmetalV1alpha1BucketName.builder()
                    .name("my-smartbucket")
                    .build())
                .build())
            .input("What are the key points in this document?")
            .objectId("document.pdf")
            .requestId("<YOUR-REQUEST-ID>")
            .build();
        QueryDocumentQueryResponse response = client.query().documentQuery(params);
    }
}
```
```

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

### Start New Raindrop Application (Claude Code)

Source: https://docs.liquidmetal.ai/tutorials/claude-code-mcp-setup

Initiates the creation of a new Raindrop application using Claude Code. This can be done via a slash command or a direct MCP tool call.

```bash
/new-raindrop-app
```

```text
Claude, call the LiquidMetal Raindrop:login MCP tool to start a new application development session.
```

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

### Complete Deployment Workflow Example

Source: https://docs.liquidmetal.ai/reference/cli/build

A comprehensive example demonstrating the full deployment lifecycle for a new application, from initialization and code generation to deployment and status monitoring.

```bash
# Initialize project structure
raindrop build init my-app
cd my-app

# Edit raindrop.manifest to define your application
# Add handlers, databases, services

# Generate TypeScript types and handler scaffolding
raindrop build generate

# Write your handler logic in src/handlers/

# Deploy and start in one command
raindrop build deploy --start

# Monitor deployment progress
raindrop build status
```

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

### JavaScript Client Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use the JavaScript client to query a document.

```APIDOC
## JavaScript Client Example

### Description
Example of how to use the JavaScript client to query a document.

### Code
```javascript
import Raindrop from '@liquidmetal-ai/lm-raindrop';

const client = new Raindrop();

const response = await client.query.documentQuery({
  bucketLocation: { bucket: { name: 'my-smartbucket' } },
  input: 'What are the key points in this document?',
  objectId: 'document.pdf',
  requestId: '<YOUR-REQUEST-ID>',
});

console.log(response.answer);
```
```

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

### Start New Working Memory Session Example

Source: https://docs.liquidmetal.ai/reference/smartmemory

This TypeScript example illustrates starting a new working memory session and immediately adding the first memory entry. It assumes the 'memory' object is bound.

```typescript
// Start a new working memory session
const { sessionId, workingMemory } = await memory.startWorkingMemorySession();


// Add first memory entry to the session
await workingMemory.putMemory({
  content: "User started new conversation about project planning",
  agent: "assistant"
});
```

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

### Python Client Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use the Python client to query a document.

```APIDOC
## Python Client Example

### Description
Example of how to use the Python client to query a document.

### Code
```python
from raindrop import Raindrop

client = Raindrop()
response = client.query.document_query(
    bucket_location={
        "bucket": {
            "name": "my-smartbucket"
        }
    },
    input="What are the key points in this document?",
    object_id="document.pdf",
    request_id="<YOUR-REQUEST-ID>",
)
print(response.answer)
```
```

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

### curl Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Example of how to use curl to query a document.

```APIDOC
## curl Example

### Description
Example of how to use curl to query a document.

### Code
```bash
curl -X POST "https://api.raindrop.run/v1/document_query" \
  -H "Authorization: Bearer lm_apikey_..." \
  -H "Content-Type: application/json" \
  -d '{ \
  "bucket_location": { \
    "bucket": { \
      "name": "my-smartbucket", \
      "version": "01jxanr45haeswhay4n0q8340y", \
      "application_name": "my-app" \
    } \
  }, \
  "object_id": "document.pdf", \
  "input": "What are the key points in this document?", \
  "request_id": "<YOUR-REQUEST-ID>" \
}'
```
```

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

### Search Request Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

This example demonstrates how to construct a search request to the `/v1/search` endpoint. It includes a natural language query, a request ID, bucket locations, and optional parameters like partition and pagination.

```json
{
  "input": "Show me documents containing credit card numbers or social security numbers",
  "requestId": "<YOUR-REQUEST-ID>",
  "bucketLocations": [
    {
      "bucket": {
        "name": "my-smartbucket",
        "version": "01jxanr45haeswhay4n0q8340y",
        "application_name": "my-app"
      }
    }
  ],
  "partition": "tenant-123",
  "pagination": {
    "limit": 10,
    "offset": 0
  }
}
```

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

### Install Node.js Dependencies

Source: https://docs.liquidmetal.ai/tutorials/manual-hello-world-deployment

Installs the required Node.js dependencies for the Raindrop project using npm. This step ensures all necessary packages are available for building and deploying the service.

```bash
npm install
```

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

### Start Raindrop Session - Java

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

An example of initiating a Raindrop API session using the Java SDK. It shows how to configure the client and set the necessary parameters for the smart memory location. The session creation logic is encapsulated within a main method.

```java
package com.raindrop.api.example;


import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.core.JsonValue;
import com.raindrop.api.models.startsession.StartSessionCreateParams;
import com.raindrop.api.models.startsession.StartSessionCreateResponse;
import java.util.Map;


public final class Main {
    private Main() {}


    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();


        StartSessionCreateParams params = StartSessionCreateParams.builder()
            .smartMemoryLocation(JsonValue.from(Map.of(
              "smartMemory", Map.of(
                "name",
                "memory-name",
                "application_name",
                "demo",
                "version",
                "1234"
              )
            )))
            .build();
        StartSessionCreateResponse startSession = client.startSession().create(params);
    }
}
```

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

### Get Bucket Content (Go)

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

Example of retrieving bucket content using the Go SDK.

```APIDOC
## GET /bucket/get

### Description
Retrieves the content of a specified object from a bucket.

### Method
GET (Implicit via SDK method)

### Endpoint
Not directly exposed as a REST endpoint in this example; SDK handles the abstraction.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
```json
{
  "BucketLocation": {
    "Bucket": {
      "Name": "string",
      "Version": "string",
      "ApplicationName": "string"
    }
  },
  "Key": "string"
}
```

### Request Example
```go
package main

import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
)

func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  bucket, err := client.Bucket.Get(context.TODO(), raindrop.BucketGetParams{
    BucketLocation: raindrop.BucketLocatorParam{Bucket: raindrop.LiquidmetalV1alpha1BucketNameParam{Name: "my-bucket", ApplicationName: raindrop.String("my-app"), Version: raindrop.String("01jtryx2f2f61ryk06vd8mr91p")}},
    Key: "my-key",
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", bucket.Content)
}
```

### Response
#### Success Response (200)
- **Content** (string) - The content of the object.

#### Response Example
(Response structure depends on the SDK's deserialization of the underlying API response)
```

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

### Get Semantic Memory - Go

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Example of how to retrieve semantic memory using the Go SDK.

```APIDOC
## POST /get_semantic_memory

### Description
Retrieves semantic memory for a given object ID and smart memory location.

### Method
POST

### Endpoint
(Assuming a base URL, the specific endpoint for this operation needs to be inferred or provided)

### Parameters
#### Request Body
- **ObjectID** (string) - Required - The ID of the object to retrieve semantic memory for.
- **SmartMemoryLocation** (object) - Required - Specifies the location of the smart memory.
  - **SmartMemory** (object) - Required
    - **name** (string) - Required - The name of the smart memory.
    - **application_name** (string) - Required - The name of the application.
    - **version** (string) - Required - The version of the smart memory.

### Request Example
```go
// Note: This is a conceptual representation. Actual SDK usage might differ.
// client.GetSemanticMemory.New(context.TODO(), raindrop.GetSemanticMemoryNewParams{
// 	ObjectID: "01jxanr45haeswhay4n0q8340y",
// 	SmartMemoryLocation: raindrop.GetSemanticMemoryNewParamsSmartMemoryLocation{
// 		SmartMemory: shared.LiquidmetalV1alpha1SmartMemoryNameParam{
// 			ApplicationName: raindrop.String("my-app"),
// 			Name: "memory-name",
// 			Version: raindrop.String("1234")
// 		}
// 	},
// })
```

### Response
#### Success Response (200)
- **Document** (object) - Contains the retrieved semantic memory document.
  - **title** (string) - The title of the document.
  - **content** (string) - The content of the document.
  - **category** (string) - The category of the document.

#### Response Example
```json
{
  "success": true,
  "document": {
    "title": "AI Best Practices",
    "content": "...",
    "category": "development"
  },
  "error": "example"
}
```
```

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

### Search Memory Entries - Java

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

This Java example demonstrates how to search for memory entries using the Liquidmetal AI client. It shows the setup of the client, the construction of search parameters including session ID, smart memory location, and terms, and the execution of the search query.

```java
package com.raindrop.api.example;


import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.core.JsonValue;
import com.raindrop.api.models.query.memory.MemorySearchParams;
import com.raindrop.api.models.query.memory.MemorySearchResponse;
import java.util.Map;


public final class Main {
    private Main() {}


    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();


        MemorySearchParams params = MemorySearchParams.builder()
            .sessionId("01jxanr45haeswhay4n0q8340y")
            .smartMemoryLocation(JsonValue.from(Map.of(
              "smartMemory", Map.of(
                "name",
                "memory-name",
                "application_name",
                "demo",
                "version",
                "1234"
              )
            )))
            .terms("user interface preferences")
            .build();
        MemorySearchResponse response = client.query().memory().search(params);
    }
}
```

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

### Search Response Example

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

This example illustrates the structure of a typical response from the `/v1/search` endpoint. It includes matched results, each with a chunk signature, text content, and source metadata indicating the bucket and object.

```json
{
  "results": [
    {
      "chunkSignature": "35a494ab4de3ff1157b3cf23e5e94600e24a5552cbb6db645599547075a8c3ad",
      "text": "",
      "source": {
        "bucket": {
          "moduleId": "01jxanr4xbf44jj3p62vwzh8j5",
          "bucketName": "my-smartbucket",
          "applicationVersionId": "01jxanr45haeswhay4n0q8340y",
          "applicationName": "my-app"
        },
        "object": "my-file.pdf"
      }
    }
  ]
}
```

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

### Get Procedure Using Liquidmetal AI SDKs and APIs

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Demonstrates how to retrieve procedure information using various programming languages and the command line. This involves calling the getProcedure endpoint with specific parameters like key and smart memory location. The examples cover JavaScript, Python, Go, Java, and a cURL request.

```javascript
import Raindrop from '@liquidmetal-ai/lm-raindrop';


const client = new Raindrop();


const getProcedure = await client.getProcedure.create({
  key: 'TechnicalReportSystemPrompt',
  smartMemoryLocation: { smartMemory: { name: 'memory-name', application_name: 'demo', version: '1234' } },
});


console.log(getProcedure.found);
```

```python
from raindrop import Raindrop


client = Raindrop()
get_procedure = client.get_procedure.create(
    key="TechnicalReportSystemPrompt",
    smart_memory_location={
        "smartMemory": {
            "name": "memory-name",
            "application_name": "demo",
            "version": "1234",
        }
    },
)
print(get_procedure.found)
```

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/shared"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  getProcedure, err := client.GetProcedure.New(context.TODO(), raindrop.GetProcedureNewParams{
    Key: "TechnicalReportSystemPrompt",
    SmartMemoryLocation: raindrop.GetProcedureNewParamsSmartMemoryLocation{SmartMemory: shared.LiquidmetalV1alpha1SmartMemoryNameParam{ApplicationName: raindrop.String("my-app"), Name: "memory-name", Version: raindrop.String("1234")}},
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", getProcedure.Found)
}
```

```java
package com.raindrop.api.example;


import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.core.JsonValue;
import com.raindrop.api.models.getprocedure.GetProcedureCreateParams;
import com.raindrop.api.models.getprocedure.GetProcedureCreateResponse;
import java.util.Map;


public final class Main {
    private Main() {}


    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();


        GetProcedureCreateParams params = GetProcedureCreateParams.builder()
            .key("TechnicalReportSystemPrompt")
            .smartMemoryLocation(JsonValue.from(Map.of(
              "smartMemory", Map.of(
                "name",
                "memory-name",
                "application_name",
                "demo",
                "version",
                "1234"
              )
            )))
            .build();
        GetProcedureCreateResponse getProcedure = client.getProcedure().create(params);
    }
}
```

```curl
curl -X POST "https://api.raindrop.run/v1/get_procedure" \
  -H "Authorization: Bearer lm_apikey_..." \
  -H "Content-Type: application/json" \
  -d '{
  "smart_memory_location": {
    "smartMemory": {
      "name": "memory-name",
      "application_name": "demo",
      "version": "1234"
    }
  },
  "key": "TechnicalReportSystemPrompt"
}'
```

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

### Start Raindrop Session - Go

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Demonstrates how to start a session with the Raindrop API using the Go SDK. It includes setting up the client with an API key and specifying the smart memory parameters. Error handling for session creation is also shown.

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/shared"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  startSession, err := client.StartSession.New(context.TODO(), raindrop.StartSessionNewParams{
    SmartMemoryLocation: raindrop.StartSessionNewParamsSmartMemoryLocation{SmartMemory: shared.LiquidmetalV1alpha1SmartMemoryNameParam{ApplicationName: raindrop.String("my-app"), Name: "memory-name", Version: raindrop.String("1234")}},
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", startSession.SessionID)
}
```

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

### Install Claude CLI

Source: https://docs.liquidmetal.ai/reference/cli/mcp

Provides steps to install the Claude CLI. It involves downloading the installer from the provided URL and verifying the installation by checking the version.

```shell
# Install Claude CLI
# Download from: https://claude.com/download


# Verify installation
claude --version
```

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

### Chunk Search Request Example (Placeholder)

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

This example demonstrates a placeholder for a chunk search request body. It includes a natural language query, a request ID for session tracking, and specifies the bucket locations to search within. The 'partition' field is optional for multi-tenant isolation.

```json
{
  "input": "Find documents about revenue in Q4 2023",
  "requestId": "<YOUR-REQUEST-ID>",
  "bucketLocations": [
    {
      "bucket": {
        "name": "my-smartbucket",
        "version": "01jxanr45haeswhay4n0q8340y",
        "application_name": "my-app"
      }
    }
  ],
  "partition": "tenant-123"
}
```

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

### Start Deployed Application with Raindrop CLI

Source: https://docs.liquidmetal.ai/reference/cli/build

Starts a previously deployed application by setting its version as active in the catalog. The application must be deployed and not in a locked state. Requires specifying the version if not currently set.

```bash
raindrop build start
raindrop build start -a my-app -v version-id
```

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

### Put Memory using LiquidMetal AI Java SDK

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Provides an example of how to put memory using the Java SDK. It sets up the Raindrop client and then uses the putMemory().create method with a builder pattern to specify content, session ID, and smart memory details. This example demonstrates client initialization from environment variables.

```java
package com.raindrop.api.example;


import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.core.JsonValue;
import com.raindrop.api.models.putmemory.PutMemoryCreateParams;
import com.raindrop.api.models.putmemory.PutMemoryCreateResponse;
import java.util.Map;


public final class Main {
    private Main() {}


    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();


        PutMemoryCreateParams params = PutMemoryCreateParams.builder()
            .content("User prefers dark theme for the interface")
            .sessionId("01jxanr45haeswhay4n0q8340y")
            .smartMemoryLocation(JsonValue.from(Map.of(
              "smartMemory", Map.of(
                "name",
                "memory-name",
                "application_name",
                "demo",
                "version",
                "1234"
              )
            )))
            .build();
        PutMemoryCreateResponse putMemory = client.putMemory().create(params);
    }
}
```

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

### Install LiquidMetal SDK with npm

Source: https://docs.liquidmetal.ai/tutorials/netlify-integration

Installs the LiquidMetal SDK package for Node.js projects. This is a prerequisite for using LiquidMetal services in your serverless functions. It is typically run using a package manager like npm or yarn.

```bash
npm install @liquidmetal-ai/lm-raindrop
```

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

### Start Session API

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

This API endpoint initiates a new session for interacting with smart memory.

```APIDOC
## POST /v1/start_session

### Description
Initiates a new session for interacting with smart memory.

### Method
POST

### Endpoint
/v1/start_session

### Parameters
#### Request Body
- **smart_memory_location** (object) - Required - Details for targeting the correct smart memory instance.
  - **smartMemory** (object) - Required
    - **name** (string) - Required - The name of the smart memory.
    - **application_name** (string) - Required - The name of the application.
    - **version** (string) - Required - The version of the smart memory.

### Request Example
```json
{
  "smart_memory_location": {
    "smartMemory": {
      "name": "memory-name",
      "application_name": "demo",
      "version": "1234"
    }
  }
}
```

### Response
#### Success Response (200)
- **sessionId** (string) - The unique identifier for the created session.

#### Response Example
```json
{
  "sessionId": "01jxanr45haeswhay4n0q8340y"
}
```
```

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

### Initialize Raindrop Project with CLI

Source: https://docs.liquidmetal.ai/tutorials/manual-hello-world-deployment

Initializes a new Raindrop application and navigates into its directory. This command sets up the basic project structure including a `raindrop.manifest` file.

```bash
raindrop build init hello-world
cd hello-world
```

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

### Retrieve Object Content with Python Raindrop SDK

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

This example demonstrates retrieving object content using the Python Raindrop SDK. It involves initializing the client and calling the bucket get method with specified bucket and key. Ensure the 'raindrop' package is installed.

```python
from raindrop import Raindrop


client = Raindrop()
bucket = client.bucket.get(
    bucket_location={
        "bucket": {
            "name": "my-smartbucket"
        }
    },
    key="my-key",
)
print(bucket.content)
```

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

### Summarize Page using Go Raindrop Client

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Provides a Go example for summarizing a page using the Liquidmetal AI Go SDK. It includes setting up the client with an API key and making the summarize page request.

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  response, err := client.Query.SumarizePage(context.TODO(), raindrop.QuerySumarizePageParams{
    Page: 1,
    PageSize: 10,
    RequestID: "<YOUR-REQUEST-ID>",
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.Summary)
}
```

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

### Get Working Memory Session Example

Source: https://docs.liquidmetal.ai/reference/smartmemory

This TypeScript example demonstrates how to retrieve an existing working memory session using its ID and then interact with it, specifically by fetching the 10 most recent memory entries.

```typescript
// Retrieve an existing working memory session
const sessionId = "session-123";
const workingMemory = await memory.getWorkingMemorySession(sessionId);


// Use the working memory session
const entries = await workingMemory.getMemory({ nMostRecent: 10 });
```

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

### Get Object (cURL)

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

Example of retrieving an object using cURL.

```APIDOC
## POST /v1/get_object

### Description
Retrieves a specific object from a bucket using a POST request with cURL.

### Method
POST

### Endpoint
`/v1/get_object`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **key** (string) - Required - The key of the object to retrieve.
- **bucket_location** (object) - Required - Specifies the bucket details.
  - **bucket** (object) - Required - The bucket information.
    - **name** (string) - Required - The name of the bucket.
    - **version** (string) - Optional - The version of the bucket.
    - **application_name** (string) - Optional - The name of the application associated with the bucket.

### Request Example
```bash
curl -X POST "https://api.raindrop.run/v1/get_object" \
  -H "Authorization: Bearer lm_apikey_..." \
  -H "Content-Type: application/json" \
  -d '{ 
  "key": "my-key",
  "bucket_location": {
    "bucket": {
      "name": "my-smartbucket",
      "version": "01jxanr45haeswhay4n0q8340y",
      "application_name": "my-app"
    }
  }
}'
```

### Response
#### Success Response (200)
- **content** (string) - The content of the object.
- **contentType** (string) - The content type of the object.

#### Response Example
```json
{
  "content": "example",
  "contentType": "example"
}
```
```

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

### Verify AI Assistant Installation

Source: https://docs.liquidmetal.ai/reference/cli/mcp

Verifies that the necessary AI assistant command-line interfaces (CLIs) are installed and accessible on your system. This check is crucial before proceeding with Raindrop MCP integration setup.

```bash
# For Claude
claude --version

# For Gemini
gemini --version
```

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

### Get Actor Namespace in Specific Jurisdiction (TypeScript)

Source: https://docs.liquidmetal.ai/reference/actor

Obtains an ActorNamespace within a specified jurisdiction, allowing for geographically partitioned actor access. This example shows how to get the 'eu' jurisdiction namespace for data actors.

```typescript
// Create EU jurisdiction namespace
const euActors = env.DATA_ACTOR.jurisdiction('eu');
const euActorId = euActors.idFromName("eu-user-123");

```

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

### Search Data with Raindrop SDK (Go)

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Provides a Go example for performing a search query with the Raindrop SDK. It includes client initialization with an API key, setting up search parameters including bucket locations and input, and handling potential errors. Dependencies include the 'lm-raindrop-go-sdk' package.

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  response, err := client.Query.Search(context.TODO(), raindrop.QuerySearchParams{
    BucketLocations: []raindrop.BucketLocatorParam{raindrop.BucketLocatorParam{Bucket: raindrop.LiquidmetalV1alpha1BucketNameParam{Name: "my-bucket", ApplicationName: raindrop.String("my-app"), Version: raindrop.String("01jtryx2f2f61ryk06vd8mr91p")}}},
    Input: "All my files",
    RequestID: "<YOUR-REQUEST-ID>",
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.Pagination)
}
```

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

### Perform Chunk Search using Go SDK

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Demonstrates how to perform a chunk search in Go using the LiquidMetal Go SDK. This example shows client initialization with an API key and constructing the search parameters, including bucket location and input query.

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  response, err := client.Query.ChunkSearch(context.TODO(), raindrop.QueryChunkSearchParams{
    BucketLocations: []raindrop.BucketLocatorParam{raindrop.BucketLocatorParam{Bucket: raindrop.LiquidmetalV1alpha1BucketNameParam{Name: "my-bucket", ApplicationName: raindrop.String("my-app"), Version: raindrop.String("01jtryx2f2f61ryk06vd8mr91p ")}}},
    Input: "Find documents about revenue in Q4 2023",
    RequestID: "<YOUR-REQUEST-ID>",
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", response.Results)
}
```

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

### Example: Retrieve and parse user data with get

Source: https://docs.liquidmetal.ai/reference/kv-cache

An example demonstrating how to retrieve user data from KV Cache as a JSON object and access its properties. It uses the 'json' type specifier for parsing.

```typescript
// Get user data as JSON object
const userData = await env.demoKvCache.get<{name: string, email: string}>('user:123', 'json');
if (userData) {
  console.log(`User: ${userData.name}`); // Access parsed object properties
}

```

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

### Get Bucket Content (Java)

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

Example of retrieving bucket content using the Java SDK.

```APIDOC
## GET /bucket/get

### Description
Retrieves the content of a specified object from a bucket.

### Method
GET (Implicit via SDK method)

### Endpoint
Not directly exposed as a REST endpoint in this example; SDK handles the abstraction.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
```json
{
  "bucketLocation": {
    "bucket": {
      "name": "string"
    }
  },
  "key": "string"
}
```

### Request Example
```java
package com.raindrop.api.example;

import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.models.bucket.BucketGetParams;
import com.raindrop.api.models.bucket.BucketGetResponse;
import com.raindrop.api.models.query.BucketLocator;
import com.raindrop.api.models.query.LiquidmetalV1alpha1BucketName;

public final class Main {
    private Main() {}

    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();

        BucketGetParams params = BucketGetParams.builder()
            .bucketLocation(BucketLocator.Bucket.builder()
                .bucket(LiquidmetalV1alpha1BucketName.builder()
                    .name("my-smartbucket")
                    .build())
                .build())
            .key("my-key")
            .build();
        BucketGetResponse bucket = client.bucket().get(params);
    }
}
```

### Response
#### Success Response (200)
- **bucket** (BucketGetResponse) - Contains the object's content and metadata.

#### Response Example
(Response structure depends on the SDK's deserialization of the underlying API response)
```

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

### Implement Hello World Service in TypeScript

Source: https://docs.liquidmetal.ai/tutorials/manual-hello-world-deployment

Provides the TypeScript implementation for a simple 'Hello World' Raindrop service. It extends the `Service` class from the `@liquidmetal-ai/raindrop-framework` and defines a `fetch` method that returns 'Hello World!'.

```typescript
import { Service } from '@liquidmetal-ai/raindrop-framework';
import { Env } from './raindrop.gen';


export default class extends Service<Env> {
  async fetch(request: Request): Promise<Response> {
    return new Response('Hello World!');
  }
}
```

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

### Get Bucket Content (Python)

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

Example of retrieving bucket content using the Python SDK.

```APIDOC
## GET /bucket/get

### Description
Retrieves the content of a specified object from a bucket.

### Method
GET (Implicit via SDK method)

### Endpoint
Not directly exposed as a REST endpoint in this example; SDK handles the abstraction.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
```json
{
  "bucketLocation": {
    "bucket": {
      "name": "string"
    }
  },
  "key": "string"
}
```

### Request Example
```python
from raindrop import Raindrop

client = Raindrop()
bucket = client.bucket.get(
    bucket_location={
        "bucket": {
            "name": "my-smartbucket"
        }
    },
    key="my-key",
)
print(bucket.content)
```

### Response
#### Success Response (200)
- **content** (string) - The content of the object.
- **contentType** (string) - The content type of the object.

#### Response Example
```json
{
  "content": "example",
  "contentType": "example"
}
```
```

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

### Get Bucket Content (JavaScript)

Source: https://docs.liquidmetal.ai/sdk/examples/object-storage

Example of retrieving bucket content using the JavaScript SDK.

```APIDOC
## GET /bucket/get

### Description
Retrieves the content of a specified object from a bucket.

### Method
GET (Implicit via SDK method)

### Endpoint
Not directly exposed as a REST endpoint in this example; SDK handles the abstraction.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
```json
{
  "bucketLocation": {
    "bucket": {
      "name": "string"
    }
  },
  "key": "string"
}
```

### Request Example
```javascript
import Raindrop from '@liquidmetal-ai/lm-raindrop';

const client = new Raindrop();

const bucket = await client.bucket.get({
  bucketLocation: { bucket: { name: 'my-smartbucket' } },
  key: 'my-key',
});

console.log(bucket.content);
```

### Response
#### Success Response (200)
- **content** (string) - The content of the object.
- **contentType** (string) - The content type of the object.

#### Response Example
```json
{
  "content": "example",
  "contentType": "example"
}
```
```

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

### Get Semantic Memory - cURL

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Example of how to retrieve semantic memory using a cURL request.

```APIDOC
## POST /v1/get_semantic_memory

### Description
Retrieves semantic memory for a given object ID and smart memory location.

### Method
POST

### Endpoint
https://api.raindrop.run/v1/get_semantic_memory

### Parameters
#### Request Body
- **smart_memory_location** (object) - Required - Specifies the location of the smart memory.
  - **smartMemory** (object) - Required
    - **name** (string) - Required - The name of the smart memory.
    - **application_name** (string) - Required - The name of the application.
    - **version** (string) - Required - The version of the smart memory.
- **object_id** (string) - Required - The ID of the object to retrieve semantic memory for.

### Request Example
```json
{
  "smart_memory_location": {
    "smartMemory": {
      "name": "memory-name",
      "application_name": "demo",
      "version": "1234"
    }
  },
  "object_id": "01jxanr45haeswhay4n0q8340y"
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **document** (object) - Contains the retrieved semantic memory document.
  - **title** (string) - The title of the document.
  - **content** (string) - The content of the document.
  - **category** (string) - The category of the document.
- **error** (string) - An example error message if the operation failed.

#### Response Example
```json
{
  "success": true,
  "document": {
    "title": "AI Best Practices",
    "content": "...",
    "category": "development"
  },
  "error": "example"
}
```
```

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

### Perform Chunk Search using Java SDK

Source: https://docs.liquidmetal.ai/sdk/examples/smartbucket

Provides a Java example for executing a chunk search. It demonstrates initializing the Raindrop client and building the search parameters, specifying the bucket and input query for retrieval.

```java
package com.raindrop.api.example;


import com.raindrop.api.client.RaindropClient;
import com.raindrop.api.client.okhttp.RaindropOkHttpClient;
import com.raindrop.api.models.query.BucketLocator;
import com.raindrop.api.models.query.LiquidmetalV1alpha1BucketName;
import com.raindrop.api.models.query.QueryChunkSearchParams;
import com.raindrop.api.models.query.QueryChunkSearchResponse;


public final class Main {
    private Main() {}


    public static void main(String[] args) {
        RaindropClient client = RaindropOkHttpClient.fromEnv();


        QueryChunkSearchParams params = QueryChunkSearchParams.builder()
            .addBucketLocation(BucketLocator.Bucket.builder()
                .bucket(LiquidmetalV1alpha1BucketName.builder()
                    .name("my-smartbucket")
                    .build())
                .build())
            .input("Find documents about revenue in Q4 2023")
            .requestId("<YOUR-REQUEST-ID>")
            .build();
        QueryChunkSearchResponse response = client.query().chunkSearch(params);
    }
}
```

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

### Get Semantic Memory - Java

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Example of how to retrieve semantic memory using the Java SDK.

```APIDOC
## POST /get_semantic_memory

### Description
Retrieves semantic memory for a given object ID and smart memory location.

### Method
POST

### Endpoint
(Assuming a base URL, the specific endpoint for this operation needs to be inferred or provided)

### Parameters
#### Request Body
- **objectId** (string) - Required - The ID of the object to retrieve semantic memory for.
- **smartMemoryLocation** (JsonValue) - Required - Specifies the location of the smart memory.
  - **smartMemory** (object) - Required
    - **name** (string) - Required - The name of the smart memory.
    - **application_name** (string) - Required - The name of the application.
    - **version** (string) - Required - The version of the smart memory.

### Request Example
```java
// GetSemanticMemoryCreateParams params = GetSemanticMemoryCreateParams.builder()
//     .objectId("01jxanr45haeswhay4n0q8340y")
//     .smartMemoryLocation(JsonValue.from(Map.of(
//       "smartMemory", Map.of(
//         "name", "memory-name",
//         "application_name", "demo",
//         "version", "1234"
//       )
//     )))
//     .build();
// GetSemanticMemoryCreateResponse getSemanticMemory = client.getSemanticMemory().create(params);
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **document** (object) - Contains the retrieved semantic memory document.
  - **title** (string) - The title of the document.
  - **content** (string) - The content of the document.
  - **category** (string) - The category of the document.
- **error** (string) - An example error message if the operation failed.

#### Response Example
```json
{
  "success": true,
  "document": {
    "title": "AI Best Practices",
    "content": "...",
    "category": "development"
  },
  "error": "example"
}
```
```

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

### List Stored Procedures with Go SDK

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Provides an example of listing stored procedures using the Go SDK for LiquidMetal AI. It includes setting up the client with an API key and defining the smart memory location parameters.

```go
package main


import (
  "context"
  "fmt"

  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/option"
  "github.com/LiquidMetal-AI/lm-raindrop-go-sdk/shared"
)


func main() {
  client := raindrop.NewClient(
    option.WithAPIKey("My API Key"),
  )
  listProcedure, err := client.ListProcedures.New(context.TODO(), raindrop.ListProcedureNewParams{
    SmartMemoryLocation: raindrop.ListProcedureNewParamsSmartMemoryLocation{SmartMemory: shared.LiquidmetalV1alpha1SmartMemoryNameParam{ApplicationName: raindrop.String("my-app"), Name: "memory-name", Version: raindrop.String("1234")}},
  })
  if err != nil {
    panic(err.Error())
  }
  fmt.Printf("%+v\n", listProcedure.Procedures)
}
```

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

### Get Semantic Memory - Python

Source: https://docs.liquidmetal.ai/sdk/examples/smart-memory

Example of how to retrieve semantic memory using the Python SDK.

```APIDOC
## POST /get_semantic_memory

### Description
Retrieves semantic memory for a given object ID and smart memory location.

### Method
POST

### Endpoint
(Assuming a base URL, the specific endpoint for this operation needs to be inferred or provided)

### Parameters
#### Request Body
- **object_id** (string) - Required - The ID of the object to retrieve semantic memory for.
- **smart_memory_location** (object) - Required - Specifies the location of the smart memory.
  - **smartMemory** (object) - Required
    - **name** (string) - Required - The name of the smart memory.
    - **application_name** (string) - Required - The name of the application.
    - **version** (string) - Required - The version of the smart memory.

### Request Example
```python
{
    "object_id": "01jxanr45haeswhay4n0q8340y",
    "smart_memory_location": {
        "smartMemory": {
            "name": "memory-name",
            "application_name": "demo",
            "version": "1234"
        }
    }
}
```

### Response
#### Success Response (200)
- **success** (boolean) - Indicates if the operation was successful.
- **document** (object) - Contains the retrieved semantic memory document.
  - **title** (string) - The title of the document.
  - **content** (string) - The content of the document.
  - **category** (string) - The category of the document.
- **error** (string) - An example error message if the operation failed.

#### Response Example
```json
{
  "success": true,
  "document": {
    "title": "AI Best Practices",
    "content": "...",
    "category": "development"
  },
  "error": "example"
}
```
```
Tokens:
Raw