GL Connectors Tool SDK

Framework-agnostic tool SDK for building tools that work with GLLM Core, LangChain, and Google ADK.

Installation

(Alternative to uv add would be pip install)

# Core SDK only
uv add gl-connectors-tools

# With GLLM Core support
uv add gl-connectors-tools[gllm]

# With LangChain support
uv add gl-connectors-tools[langchain]

# With Google ADK Support
uv add gl-connectors-tools[adk]

# With all frameworks
uv add gl-connectors-tools[all]

Quick Start

Creating a Tool

from pydantic import BaseModel, Field
from gl_connectors_tools.tools import BaseTool


class SearchInput(BaseModel):
    query: str = Field(description="Search query")
    max_results: int = Field(default=10, description="Maximum results to return")


class SearchTool(BaseTool):
    name = "search"
    description = "Searches for information"
    input_schema = SearchInput

    def run(self, query: str, max_results: int = 10) -> str:
        # Your implementation here
        return f"Found {max_results} results for: {query}"

Using with Different Frameworks

from gl_connectors_tools.adapters import (
    to_gllm_tool,      # GLLM Core
    to_langchain_tool,  # LangChain
    to_adk_function,    # Google ADK
)

tool = SearchTool()

# Convert to GLLM Core Tool
gllm_tool = to_gllm_tool(tool)

# Convert to LangChain StructuredTool
lc_tool = to_langchain_tool(tool)

# Convert to ADK FunctionDeclaration
func_decl, callable_fn = to_adk_function(tool)

Migrating from LangChain (Zero-Change!)

Just change the import. The SDK accepts LangChain naming conventions out of the box:

- from langchain_core.tools import BaseTool
+ from gl_connectors_tools.tools import BaseTool

  class MyTool(BaseTool):
      name = "my_tool"
      description = "..."
      args_schema = MyInput      # ✅ Works as-is!

      def _run(self, **kwargs):  # ✅ Works as-is!
          # implementation unchanged

The SDK supports both naming conventions:

Alternative: Wrapper for Existing Instances

If you have existing LangChain tool instances you can't modify:

from gl_connectors_tools.adapters.langchain import LangChainToolWrapper

# Existing LangChain tool instance
from my_app.tools import MyLangChainTool

# Wrap it
sdk_tool = LangChainToolWrapper(MyLangChainTool())

# Now use it with any adapter
gllm_tool = to_gllm_tool(sdk_tool)

Predefined Tools

from gl_connectors_tools.predefined import TimeTool

tool = TimeTool()
result = tool.run(timezone="Asia/Jakarta")

Architecture

┌─────────────────────────────────────────────────┐
│               Your SDK Tools                     │
│         (inherit from BaseTool)                  │
└─────────────────────────────────────────────────┘
                      │
        ┌─────────────┼─────────────┐
        ▼             ▼             ▼
   ┌─────────┐  ┌─────────┐  ┌─────────┐
   │  GLLM   │  │LangChain│  │   ADK   │
   │ Adapter │  │ Adapter │  │ Adapter │
   └─────────┘  └─────────┘  └─────────┘

The SDK owns the tool interface. Frameworks become output adapters, not the source of truth.