Add tool embeddings (800 tools, 3072-dim) + OpenAPI spec + scripts

README.md

@@ -0,0 +1,170 @@
+---
+license: cc-by-nc-4.0
+configs:
+  - config_name: embeddings
+    data_files: "embeddings.parquet"
+    default: true
+  - config_name: tools
+    data_files: "tools.parquet"
+task_categories:
+  - feature-extraction
+  - text-classification
+language:
+  - "en"
+  - "no"
+tags:
+  - embeddings
+  - openapi
+  - tripletex
+  - accounting
+  - api-tools
+  - rag
+  - lancedb
+  - pydantic
+size_categories:
+  - n<1K
+---
+
+# Tripletex API Tool Embeddings
+
+Pre-computed embeddings for 800 Tripletex accounting API tools, extracted from the OpenAPI 3.0.1 spec and embedded with Google `gemini-embedding-001` (3072 dimensions).
+
+Built for RAG-based tool filtering in the [AI Accounting Agent](https://github.com/kuben-labs/nmai) competition project.
+
+## Quick Start
+
+```python
+from datasets import load_dataset
+
+# Full embeddings (800 tools, 3072-dim vectors) — ready for RAG
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings")
+
+# Lightweight: tool metadata only, no embedding vectors
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings", name="tools")
+```
+
+## Configurations
+
+| Config | Default | Columns | Size | Use case |
+|--------|---------|---------|------|----------|
+| `embeddings` | Yes | name, description, parameters, embedding | ~9 MB | RAG search, vector index |
+| `tools` | | name, description, parameters | ~50 KB | Browsing, filtering, analysis |
+
+## Schema
+
+### `embeddings` config
+
+```python
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings")
+example = ds["train"][0]
+
+example["name"]         # "AccountantDashboardNews_get"
+example["description"]  # "Get public news articles"
+example["parameters"]   # '{"from": "integer", "count": "integer", ...}'  (JSON string)
+example["embedding"]    # [3072 floats] — gemini-embedding-001 vector
+```
+
+### `tools` config
+
+```python
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings", name="tools")
+example = ds["train"][0]
+
+example["name"]         # "AccountantDashboardNews_get"
+example["description"]  # "Get public news articles"
+example["parameters"]   # '{"from": "integer", "count": "integer", ...}'  (JSON string)
+```
+
+## Data Summary
+
+- **800 API tools** from the Tripletex accounting API (OpenAPI 3.0.1)
+- **3072-dimensional embeddings** via Google `gemini-embedding-001`
+- **Parameters** stored as JSON strings mapping param names to types
+- **Source:** `openapi.json` included in this repo (3.5 MB, 546 paths, 2167 schemas)
+
+## Using with LanceDB
+
+```python
+from datasets import load_dataset
+import lancedb
+
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings")
+
+# Convert to LanceDB
+db = lancedb.connect(".tool_embeddings")
+records = [
+    {
+        "name": row["name"],
+        "description": row["description"],
+        "parameters": row["parameters"],
+        "embedding": row["embedding"],
+    }
+    for row in ds["train"]
+]
+table = db.create_table("tools", data=records, mode="overwrite")
+
+# Search
+results = table.search(query_embedding).limit(100).to_list()
+```
+
+## Using with FAISS
+
+```python
+from datasets import load_dataset
+import numpy as np
+import faiss
+
+ds = load_dataset("valiantlynxz/tripletex-tool-embeddings")
+
+embeddings = np.array(ds["train"]["embedding"], dtype=np.float32)
+index = faiss.IndexFlatIP(3072)
+faiss.normalize_L2(embeddings)
+index.add(embeddings)
+
+# Search
+query = np.array([query_embedding], dtype=np.float32)
+faiss.normalize_L2(query)
+distances, indices = index.search(query, k=100)
+tool_names = [ds["train"][int(i)]["name"] for i in indices[0]]
+```
+
+## Regenerating Embeddings
+
+The `scripts/` directory contains the original embedding pipeline:
+
+- `scripts/embeddings.py` — Google Gemini embedding provider
+- `scripts/rag_tool_filter.py` — OpenAPI-to-embedding pipeline + LanceDB vector store
+
+```python
+# Requires: google-genai, lancedb
+# Requires: GCP_API_KEY environment variable
+
+from scripts.embeddings import get_embedding_provider
+from scripts.rag_tool_filter import ToolEmbedder, ToolVectorStore, index_openapi_tools
+import json, asyncio
+
+with open("openapi.json") as f:
+    spec = json.load(f)
+
+provider = get_embedding_provider()
+embedder = ToolEmbedder(provider)
+store = ToolVectorStore(".tool_embeddings")
+asyncio.run(index_openapi_tools(spec, store, embedder))
+```
+
+## Repo Structure
+
+```
+tripletex-tool-embeddings/
+├── README.md
+├── embeddings.parquet      # 800 tools with 3072-dim embeddings
+├── tools.parquet           # 800 tools metadata only (lightweight)
+├── openapi.json            # Source Tripletex OpenAPI 3.0.1 spec (3.5 MB)
+└── scripts/
+    ├── embeddings.py       # Google Gemini embedding provider
+    └── rag_tool_filter.py  # OpenAPI extraction + LanceDB indexing
+```
+
+## Source Project
+
+Part of the [nmai](https://github.com/kuben-labs/nmai) project — `ai-accounting-agent/`.

embeddings.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1fab870063479bfd830d8a5ce123de399c5edb0f22ae00c26a9568f44507873
+size 10494645

scripts/embeddings.py

@@ -0,0 +1,123 @@
+"""Google embeddings provider using pydantic-ai.
+
+This module provides direct integration with Google Gemini embedding models
+without relying on machine-core or model-providers packages.
+"""
+
+import os
+from typing import List, Optional
+
+from loguru import logger
+
+
+class GoogleEmbeddingProvider:
+    """Wrapper for Google Gemini embedding model.
+
+    This class provides a simple interface compatible with the existing
+    ToolEmbedder class that expects an `embed` method.
+    """
+
+    def __init__(
+        self,
+        model_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        dimensions: Optional[int] = None,
+    ):
+        """Initialize the Google embedding provider.
+
+        Args:
+            model_name: The embedding model name (defaults to gemini-embedding-001)
+            api_key: Google API key (defaults to GCP_API_KEY env var)
+            dimensions: Output embedding dimensions (defaults to EMBEDDING_DIMENSIONS env var or 3072)
+        """
+        self.model_name = model_name or os.getenv(
+            "EMBEDDING_MODEL", "gemini-embedding-001"
+        )
+        self.api_key = api_key or os.getenv("GCP_API_KEY")
+        self.dimensions = dimensions or int(os.getenv("EMBEDDING_DIMENSIONS", "3072"))
+
+        if not self.api_key:
+            raise ValueError(
+                "Google API key is required for embeddings. "
+                "Set GCP_API_KEY environment variable or pass api_key parameter."
+            )
+
+        # Import here to avoid issues if google-genai is not installed
+        try:
+            from google import genai  # type: ignore
+
+            self._client = genai.Client(api_key=self.api_key)
+            self._types = genai.types
+            self._initialized = True
+            logger.info(f"Initialized Google embedding provider: {self.model_name}")
+        except ImportError:
+            logger.error("google-genai package not installed")
+            self._client = None
+            self._types = None
+            self._initialized = False
+
+    def embed(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of texts.
+
+        Args:
+            texts: List of text strings to embed
+
+        Returns:
+            List of embedding vectors
+        """
+        if not self._initialized or self._client is None:
+            logger.warning("Google embedding provider not initialized")
+            return [[] for _ in texts]
+
+        try:
+            # Use Google's new genai SDK
+            result = self._client.models.embed_content(
+                model=self.model_name,
+                contents=texts,
+                config=self._types.EmbedContentConfig(  # type: ignore
+                    task_type="RETRIEVAL_DOCUMENT",
+                    output_dimensionality=self.dimensions,
+                ),
+            )
+
+            # Extract embeddings
+            return [e.values for e in result.embeddings]
+
+        except Exception as e:
+            logger.error(f"Failed to embed texts: {e}")
+            return [[] for _ in texts]
+
+    async def embed_async(self, texts: List[str]) -> List[List[float]]:
+        """Async version of embed - delegates to sync for now.
+
+        Args:
+            texts: List of text strings to embed
+
+        Returns:
+            List of embedding vectors
+        """
+        import asyncio
+
+        return await asyncio.to_thread(self.embed, texts)
+
+
+def get_embedding_provider(
+    model_name: Optional[str] = None,
+    api_key: Optional[str] = None,
+    dimensions: Optional[int] = None,
+) -> GoogleEmbeddingProvider:
+    """Factory function to create a Google embedding provider.
+
+    Args:
+        model_name: The embedding model name
+        api_key: Google API key
+        dimensions: Output embedding dimensions
+
+    Returns:
+        GoogleEmbeddingProvider instance
+    """
+    return GoogleEmbeddingProvider(
+        model_name=model_name,
+        api_key=api_key,
+        dimensions=dimensions,
+    )

scripts/rag_tool_filter.py

@@ -0,0 +1,424 @@
+"""RAG-based tool filtering system for reducing context size.
+
+This module provides functionality to:
+1. Extract and embed all available MCP tools
+2. Store embeddings in a vector database (LanceDB)
+3. Filter tools based on semantic similarity to task prompts
+4. Return relevant tool names (set[str]) for use with FilteredToolset
+
+The actual tool filtering is done by pydantic-ai's native FilteredToolset,
+which preserves full parameter schemas. This module only handles the
+embedding index and semantic search to determine WHICH tools are relevant.
+"""
+
+import json
+import asyncio
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Set, Tuple
+from dataclasses import dataclass
+
+from loguru import logger
+
+try:
+    import lancedb
+except ImportError:
+    lancedb = None
+
+
+@dataclass
+class ToolMetadata:
+    """Metadata for a single tool."""
+
+    name: str
+    description: str
+    parameters: Dict[str, Any]
+    category: Optional[str] = None
+    embedding: Optional[List[float]] = None
+
+
+class ToolEmbedder:
+    """Handles embedding of tool descriptions for semantic search."""
+
+    def __init__(self, embedding_provider=None):
+        """Initialize the tool embedder.
+
+        Args:
+            embedding_provider: Optional embedding provider (GoogleEmbeddingProvider).
+                               If None, will try to get from environment.
+        """
+        self.embedding_provider = embedding_provider
+        # If embedding_provider has a provider attribute, extract the actual provider
+        if embedding_provider and hasattr(embedding_provider, "provider"):
+            self.provider = embedding_provider.provider
+        else:
+            self.provider = embedding_provider
+
+    async def embed_tools_batch(
+        self, tools: List[ToolMetadata], batch_size: int = 32
+    ) -> List[ToolMetadata]:
+        """Embed multiple tools in batches for efficiency.
+
+        Args:
+            tools: List of tools to embed
+            batch_size: Number of tools to embed per batch
+
+        Returns:
+            List of tools with embeddings added
+        """
+        if self.provider is None:
+            logger.warning("No embedding provider configured, skipping embeddings")
+            return tools
+
+        embedded_tools = []
+        total = len(tools)
+
+        for i in range(0, total, batch_size):
+            batch = tools[i : i + batch_size]
+            logger.debug(f"Embedding batch {i // batch_size + 1} ({len(batch)} tools)")
+
+            try:
+                # Create text representations for embedding
+                tool_texts = []
+                for tool in batch:
+                    # Limit parameters JSON to first 2000 chars for embedding
+                    params_str = json.dumps(tool.parameters, indent=2, default=str)
+                    if len(params_str) > 2000:
+                        params_str = params_str[:2000] + "..."
+
+                    tool_text = f"""
+Tool: {tool.name}
+Description: {tool.description}
+Parameters: {params_str}
+                    """.strip()
+                    tool_texts.append(tool_text)
+
+                # Get embeddings for the batch
+                embeddings = await asyncio.to_thread(self.provider.embed, tool_texts)
+
+                # Assign embeddings to tools
+                for tool, embedding in zip(batch, embeddings):
+                    if embedding:
+                        tool.embedding = embedding
+                    embedded_tools.append(tool)
+
+            except Exception as e:
+                logger.warning(f"Failed to embed batch: {e}")
+                embedded_tools.extend(batch)
+
+        return embedded_tools
+
+    async def embed_text(self, text: str) -> List[float]:
+        """Embed a text string (e.g., task prompt).
+
+        Args:
+            text: Text to embed
+
+        Returns:
+            Embedding vector
+        """
+        if self.provider is None:
+            logger.warning("No embedding provider configured")
+            return []
+
+        try:
+            embeddings = await asyncio.to_thread(self.provider.embed, [text])
+            if embeddings and len(embeddings) > 0:
+                return embeddings[0]
+            return []
+        except Exception as e:
+            logger.error(f"Failed to embed text: {e}")
+            return []
+
+
+class ToolVectorStore:
+    """Manages tool embeddings and vector similarity search using LanceDB."""
+
+    def __init__(self, db_path: str = ".tool_embeddings"):
+        """Initialize the vector store using LanceDB.
+
+        Args:
+            db_path: Path to store the LanceDB database
+        """
+        self.db_path = Path(db_path)
+        self.db_path.mkdir(exist_ok=True)
+
+        if lancedb is None:
+            raise ImportError(
+                "lancedb is required for RAG tool filtering. Install with: uv add lancedb"
+            )
+
+        self.db = lancedb.connect(str(self.db_path))
+        self.table = None
+        self.tools: Dict[str, ToolMetadata] = {}
+
+        # Load existing tools from database
+        self._load_from_disk()
+
+    def _load_from_disk(self):
+        """Load tools from LanceDB if the table exists."""
+        try:
+            if "tools" in self.db.table_names():
+                self.table = self.db.open_table("tools")
+                records = self.table.search().limit(10000).to_list()
+
+                for record in records:
+                    tool = ToolMetadata(
+                        name=record["name"],
+                        description=record["description"],
+                        parameters=record.get("parameters", {}),
+                        category=record.get("category"),
+                        embedding=record.get("embedding"),
+                    )
+                    self.tools[record["name"]] = tool
+
+                logger.info(f"Loaded {len(self.tools)} tools from LanceDB")
+            else:
+                logger.debug("No existing tools table in LanceDB")
+
+        except Exception as e:
+            logger.warning(f"Failed to load tools from LanceDB: {e}")
+
+    def _save_to_disk(self):
+        """Save tools to LanceDB with embeddings."""
+        try:
+            records = []
+            for tool_name, tool in self.tools.items():
+                records.append(
+                    {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "parameters": json.dumps(tool.parameters, default=str),
+                        "category": tool.category,
+                        "embedding": tool.embedding,
+                    }
+                )
+
+            if not records:
+                logger.warning("No tools to save")
+                return
+
+            if self.table is None:
+                self.table = self.db.create_table(
+                    "tools", data=records, mode="overwrite"
+                )
+            else:
+                self.db.drop_table("tools")
+                self.table = self.db.create_table(
+                    "tools", data=records, mode="overwrite"
+                )
+
+            logger.info(f"Saved {len(records)} tools to LanceDB with embeddings")
+
+        except Exception as e:
+            logger.error(f"Failed to save tools to LanceDB: {e}")
+            raise
+
+    def add_tool(self, tool: ToolMetadata) -> None:
+        """Add a tool to the vector store."""
+        self.tools[tool.name] = tool
+
+    def find_similar_tools(
+        self, query_embedding: List[float], top_k: int = 100
+    ) -> List[Tuple[str, float]]:
+        """Find similar tools using LanceDB vector search.
+
+        Args:
+            query_embedding: Embedding of the query (task prompt)
+            top_k: Number of top results to return
+
+        Returns:
+            List of (tool_name, similarity_score) tuples, sorted by relevance
+        """
+        if not query_embedding:
+            logger.warning("Empty query embedding, returning all tools")
+            return [(name, 0.0) for name in list(self.tools.keys())[:top_k]]
+
+        if self.table is None:
+            logger.warning("No tools indexed yet, returning all tools")
+            return [(name, 0.0) for name in list(self.tools.keys())[:top_k]]
+
+        try:
+            results = self.table.search(query_embedding).limit(top_k).to_list()
+
+            tool_scores = []
+            for result in results:
+                tool_name = result.get("name", "")
+                distance = result.get("_distance", 0.0)
+                similarity = 1.0 / (1.0 + distance)
+                tool_scores.append((tool_name, similarity))
+
+            logger.debug(f"LanceDB search found {len(tool_scores)} results")
+            return tool_scores
+
+        except Exception as e:
+            logger.error(f"LanceDB search failed: {e}")
+            return [(name, 0.0) for name in list(self.tools.keys())[:top_k]]
+
+    def get_all_tool_names(self) -> Set[str]:
+        """Get all tool names in the store."""
+        return set(self.tools.keys())
+
+
+async def index_mcp_tools(
+    toolsets: List[Any],
+    vector_store: ToolVectorStore,
+    embedder: ToolEmbedder,
+) -> None:
+    """Index all tools from MCP toolsets into the vector store.
+
+    Args:
+        toolsets: List of MCP toolsets
+        vector_store: The vector store to populate
+        embedder: The embedder to use for creating embeddings
+    """
+    logger.info("Starting MCP tool indexing...")
+
+    total_tools = 0
+    for toolset in toolsets:
+        try:
+            tools_list = await toolset.list_tools()  # type: ignore
+            logger.info(
+                f"Extracted {len(tools_list)} tools from {toolset.__class__.__name__}"
+            )
+
+            # Convert to ToolMetadata objects
+            tool_metadata_list = []
+            for mcp_tool in tools_list:
+                tool_metadata = ToolMetadata(
+                    name=mcp_tool.name,
+                    description=mcp_tool.description or "",
+                    parameters=mcp_tool.inputSchema or {},
+                )
+                tool_metadata_list.append(tool_metadata)
+
+            # Embed tools in batches
+            embedded_tools = await embedder.embed_tools_batch(
+                tool_metadata_list, batch_size=32
+            )
+
+            # Store all tools
+            for tool in embedded_tools:
+                vector_store.add_tool(tool)
+                total_tools += 1
+
+            # Save to disk
+            vector_store._save_to_disk()
+
+        except Exception as e:
+            logger.error(f"Failed to extract tools from toolset: {e}")
+            import traceback
+
+            traceback.print_exc()
+
+    logger.info(f"Tool indexing complete: {total_tools} tools indexed")
+
+
+async def index_openapi_tools(
+    spec: Dict[str, Any],
+    vector_store: ToolVectorStore,
+    embedder: ToolEmbedder,
+) -> None:
+    """Index tools from an OpenAPI spec into the vector store.
+
+    This replaces index_mcp_tools for the direct-API architecture.
+    Extracts tool names and descriptions from the OpenAPI spec's
+    operation IDs and summaries.
+
+    Args:
+        spec: Parsed OpenAPI spec JSON
+        vector_store: The vector store to populate
+        embedder: The embedder to use for creating embeddings
+    """
+    logger.info("Starting OpenAPI tool indexing...")
+
+    tool_metadata_list = []
+    paths = spec.get("paths", {})
+
+    for path, path_item in paths.items():
+        for method in ["get", "post", "put", "delete", "patch"]:
+            operation = path_item.get(method)
+            if not operation:
+                continue
+
+            operation_id = operation.get("operationId", "")
+            if not operation_id:
+                continue
+
+            tool_name = operation_id.strip("[]").replace(" ", "_")
+            description = operation.get("summary", "") or operation.get(
+                "description", ""
+            )
+            if not description:
+                description = f"{method.upper()} {path}"
+
+            # Build a simple representation for embedding
+            params = {}
+            for param in operation.get("parameters", []):
+                name = param.get("name", "")
+                if name:
+                    params[name] = param.get("schema", {}).get("type", "string")
+
+            tool_metadata = ToolMetadata(
+                name=tool_name,
+                description=description,
+                parameters=params,
+            )
+            tool_metadata_list.append(tool_metadata)
+
+    logger.info(f"Found {len(tool_metadata_list)} tools in OpenAPI spec")
+
+    # Embed in batches
+    embedded_tools = await embedder.embed_tools_batch(tool_metadata_list, batch_size=32)
+
+    # Store
+    for tool in embedded_tools:
+        vector_store.add_tool(tool)
+
+    vector_store._save_to_disk()
+    logger.info(f"OpenAPI tool indexing complete: {len(embedded_tools)} tools indexed")
+
+
+async def get_relevant_tool_names(
+    vector_store: ToolVectorStore,
+    embedder: ToolEmbedder,
+    task_prompt: str,
+    top_k: int = 100,
+) -> Set[str]:
+    """Get the set of relevant tool names for a task using RAG similarity search.
+
+    This is the main entry point for tool filtering. Returns a set of tool names
+    that can be used with pydantic-ai's FilteredToolset to filter the MCP toolset
+    while preserving full parameter schemas.
+
+    Args:
+        vector_store: The populated vector store
+        embedder: The embedder for embedding the task prompt
+        task_prompt: The task prompt to find relevant tools for
+        top_k: Number of top relevant tools to return
+
+    Returns:
+        Set of relevant tool names
+    """
+    try:
+        # Embed the task prompt
+        query_embedding = await embedder.embed_text(task_prompt)
+
+        # Find similar tools
+        similar_tool_scores = vector_store.find_similar_tools(
+            query_embedding, top_k=top_k
+        )
+
+        # Extract just the tool names
+        relevant_names = {tool_name for tool_name, score in similar_tool_scores}
+
+        logger.info(
+            f"RAG search: Found {len(relevant_names)} relevant tools "
+            f"(from {len(vector_store.tools)} total) for task: {task_prompt[:80]}..."
+        )
+
+        return relevant_names
+
+    except Exception as e:
+        logger.error(f"Error getting relevant tools: {e}")
+        # Fallback: return all tools
+        return vector_store.get_all_tool_names()

tools.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e2b20ca1d5cb953513be0ef9e8beab655d01d7ec922f8c6062382a245c55033
+size 36390