Glean API Clients

pip install glean-api-client

poetry add glean-api-client

from glean import Glean
import os

# Initialize with API token
with Glean(
    api_token=os.getenv("GLEAN_API_TOKEN", ""),
) as client:
    # Use the client...
    pass

from glean import Glean, models
import os

with Glean(
    api_token=os.getenv("GLEAN_API_TOKEN", ""),
) as client:
    # Send a chat message to Glean
    res = client.client.chat.create(messages=[
        {
            "fragments": [
                models.ChatMessageFragment(
                    text="What are the company holidays this year?",
                ),
            ],
        },
    ], timeout_millis=30000)

    # Handle response
    print(res)

npm install @gleanwork/api-client

yarn add @gleanwork/api-client

import { Glean } from "@gleanwork/api-client";

// Initialize with API token
const client = new Glean({
  apiToken: process.env.GLEAN_API_TOKEN,
});

import { Glean } from "@gleanwork/api-client";

async function run() {
  const glean = new Glean({
    apiToken: process.env.GLEAN_API_TOKEN,
  });

  const result = await glean.client.chat.create({
    messages: [
      {
        fragments: [
          {
            text: "What are the company holidays this year?",
          },
        ],
      },
    ],
  });

  // Handle the result
  console.log(result);
}

run();

go get github.com/gleanwork/api-client-go

import (
  "context"
  glean "github.com/gleanwork/api-client-go"
  "os"
)

func main() {
  ctx := context.Background()

  // Initialize with API token
  client := glean.New(
    glean.WithAPIToken(os.Getenv("GLEAN_API_TOKEN")),
  )
}

import (
  "context"
  "fmt"
  glean "github.com/gleanwork/api-client-go"
  "os"
)

func main() {
  ctx := context.Background()
  
  client := glean.New(
    glean.WithAPIToken(os.Getenv("GLEAN_API_TOKEN")),
  )
  
  // Send a chat message to Glean
  message := glean.ChatMessageFragment{
    Text: "What are the company holidays this year?",
  }
  
  chatMessage := glean.ChatMessage{
    Fragments: []glean.ChatMessageFragment{message},
  }
  
  res, err := client.Client.Chat.Create(ctx, &glean.ChatRequest{
    Messages: []glean.ChatMessage{chatMessage},
    TimeoutMillis: glean.Int64(30000),
  })
  
  if err != nil {
    fmt.Printf("Error: %v\n", err)
    return
  }
  
  // Handle response
  fmt.Println(res)
}

<dependency>
  <groupId>com.glean.api-client</groupId>
  <artifactId>glean-api-client</artifactId>
  <version>0.x.x</version> <!-- Use latest version -->
</dependency>

implementation 'com.glean.api-client:glean-api-client:0.x.x' // Use latest version

import com.glean.api_client.glean_api_client.Glean;
import java.time.OffsetDateTime;

public class Main {
  public static void main(String[] args) {
    // Initialize with API token
    Glean client = Glean.builder()
        .apiToken(System.getenv("GLEAN_API_TOKEN"))
        .build();
  }
}

import com.glean.api_client.glean_api_client.Glean;
import com.glean.api_client.glean_api_client.models.components.*;
import com.glean.api_client.glean_api_client.models.operations.ChatResponse;
import java.util.List;

public class Application {
    public static void main(String[] args) {
        Glean apiClient = Glean.builder()
            .apiToken(System.getenv("GLEAN_API_TOKEN"))
            .build();

        ChatResponse res = apiClient.client().chat().create()
            .chatRequest(ChatRequest.builder()
                .messages(List.of(
                    ChatMessage.builder()
                        .fragments(List.of(
                            ChatMessageFragment.builder()
                                .text("What are the company holidays this year?")
                                .build()))
                        .build()))
                .build())
            .call();

        if (res.chatResponse().isPresent()) {
            // Handle response
            System.out.println(res.chatResponse().get());
        }
    }
}