Skip to main content
Glama
809,825 tools. Updated 2026-11-20 02:19

"A server for performing natural language queries in Jira" matching MCP tools:

  • Search JobYap job postings by natural-language query. Matches job titles, falling back to significant keywords when the full phrase finds little. Returns result ids, titles and citable URLs for use with fetch. For structured filtering (location, company, remote, freshness) prefer search_jobs.
    ConnectorNo auth
  • Semantic / vibe search over the same nationwide ramen DB — describe what you feel like eating in natural language, English or Japanese ("rich creamy pork broth", "あっさり淡麗な醤油", "oily mazesoba", "tsukemen near Ebisu station"), and get the closest shops by meaning, each with a similarity score. Powered by multilingual embeddings (bge-m3), so English queries find shops with Japanese-only names. Role split: use search_ramen for exact facts (shop name lookup, keito/prefecture/status filters, geo radius) — use vibe_search for descriptive/fuzzy queries where no exact filter fits. Style rankings reflect only classified shops (~25%); unclassified shops still match by name and place. Tip: concrete food words (style, broth, richness, place, hours) match far better than abstract mood words ("stylish", "hardcore") — translate moods into concrete attributes before querying. Prefecture intent in the query text (北海道, 博多の…) is auto-applied as a filter (pref_source: inferred); region-style names (札幌ラーメン, 喜多方, 佐野…) stay pure style words and never restrict location. Dish-concept words (オロチョン, カラシビ, 台湾ラーメン/まぜそば, 勝浦タンタンメン) are expanded into their constituent style vocabulary before embedding (transparent via concept_expansion in the echoed query) — expansion never adds filters, so shops serving the dish always stay eligible; spicy-implying concepts additionally give spice-verified shops a small rank boost (concept_boost — a soft rerank, still no filter). Richness/hours inferred from the query text likewise act as a soft rank boost (attr_boost; attr_matched is informational) — only explicit richness/hours params and spiciness intent filter strictly.
    ConnectorNo auth
  • FREE search for paid API endpoints (x402) by task. Pass either a natural-language query (the planner will split it) or pre-split queries[]. Returns a structured plan with up to `maxRoutesPerQuery` candidates per sub-query. No auth. Limits: burst 200/10s, total 1000/15min per IP; free probes 10/h per IP, 20/h per agent. IMPORTANT: Do not fetch `route.url` directly. To execute the preferred route, call `call_endpoint({ routeId, arguments })` - `routeId` from `plan[].routes[].routeId`, `arguments` keys = `parameters[].name` of that route.
    ConnectorNo auth
  • Find quantum computing researchers and potential collaborators from 1000+ active profiles. Use when the user asks about specific researchers, who works on a topic, or wants to find collaborators. NOT for jobs (use searchJobs) or papers (use searchPapers). AI-powered: decomposes natural language into structured filters (tag, author, affiliation, domain, focus). Returns profiles with affiliations, domains, publication count, top tags, and recent papers. Data from arXiv papers published in the last 12 months. Max 50 results. Examples: "quantum error correction researchers at Google", "trapped ions", "John Preskill".
    ConnectorNo auth
  • Search Partle's product catalog by name or description. CRITICAL SEARCH INSTRUCTION: Reason from the job to the product class first, then search with a descriptive product phrase (e.g. including substrate, material, or size class). DO NOT blindly search using the user's raw conversational words. Transform questions like 'what do I need to attach a mirror to a brick wall?' into a product phrase like 'heavy duty masonry wall anchor'. Two distinct modes: - **Default (no flags)** — fast keyword search. ~100ms. Acts like a normal "dumb" search box: matches the literal words you typed against product names and descriptions, with stemming. Good for queries where the user knows the product's likely name ("BC547", "Arduino Uno", "Bosch drill"). Returns noisy/wrong results on cross-language or attribute queries ("compost bin" matches Spanish "composta", not real composters). - **`super_search=True`** — slow, high-quality. ~1–2s. Run when the user describes what they want rather than naming it: cross-language ("Schraubenzieher Set" → real screwdriver sets even without German catalog entries), attribute-style ("small metal part with a flat head"), or any case where the default returns junk. Embeds the query with voyage-3-large, takes the cosine top-50 over the corpus (with an exact-name precision boost for part numbers), then a cross-encoder reranks them. The two modes are mutually exclusive in practice — pick one based on whether the user knows the product's name or is describing it. Use this when the user asks to find a specific product or browse products matching a query. Prefer over `search_stores` when the intent is product-led ("find a drill") rather than store-led. Use `get_product` afterwards if the user wants full details for one specific result. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search term. In default mode, treated as keywords (each word matched against product text). In `super_search=True`, treated as a natural-language description. min_price: Lower bound on price in EUR. Omit for no lower bound. Null-priced rows are NOT excluded by this filter — pass `has_price=True` if you need only priced listings. max_price: Upper bound on price in EUR. Omit for no upper bound. Tip — narrow by budget: `min_price=10, max_price=50, sort_by="price_asc", has_price=True`. Products without a listed price (a large fraction of the scraped catalog) sort last under either price ordering and are kept in results unless `has_price` filters them out. tags: Comma-separated tag filter (e.g. "electronics,bluetooth"). Tags are AND-ed together. store_id: Restrict results to a single store. Use the integer `id` from `search_stores` results. sort_by: One of `price_asc`, `price_desc`, `name_asc`, `newest`, `oldest`. Omit to use the default search-relevance ranking. has_price: When True, exclude products without a listed price (~most of the scraped catalog). Use this for competitive pricing or budget-bounded shopping. When False, return only null-priced listings (rarely useful). Omit to include both. semantic: Legacy flag. Pure vector ordering, ~250ms. Mostly superseded by `super_search=True` (which uses the same vector retrieval plus a cross-encoder rerank for materially better ordering at the cost of another ~700ms). Keep using it only if you specifically want vector retrieval *without* the rerank. super_search: **Enable for natural-language / "describe what I want" queries.** ~1–2s. Embeds the query with voyage-3-large, takes the cosine top-50 (with a precision boost for exact-name matches like part numbers / SKUs), then a cross-encoder reranks them. Use whenever the user is describing rather than naming — cross-language ("Schraubenzieher Set"), attribute-style ("small black metal bracket"), or any case where the default keyword path returns junk. Don't combine with cheap browse-style queries where the user typed an exact product name — keyword default is faster there. On `relevance_score` here: better than the bi-encoder cosine, but still not a "did I find what the user wanted" gauge. Behavior to expect: gibberish or fully-off-topic queries cap around 0.35; loosely-related catalogue clusters can score 0.7+ even when no item truly matches (a "ceramic vase" query in a catalog with no vases but many ceramic flowerpots will still score high). **Read the product names** before claiming a match. The score is most useful as a relative signal within one result set — a sharp drop between rank N and N+1 marks where the catalog stops being useful for this query. limit: Max results (1–100, default 20). Larger limits are slower and consume rate budget faster. offset: Skip this many results before returning. Use for pagination (offset += limit on each follow-up call). Returns: A list of products. Each includes `id`, `name`, `price`, `currency`, `url`, `description`, `store` (id/name/address), `tags`, `images`, a canonical `partle_url`, and `relevance_score` (cosine similarity 0–1 between the query and the product's embedding when a query was provided; `None` otherwise). **Always share `partle_url` with the user so they can view the listing.** Caveat on `relevance_score`: it is monotonic *within a single search result set* (useful for spotting a big drop-off between rank 3 and rank 4), but its absolute value is not well-calibrated across queries — most results land in 0.55–0.80 regardless of whether the catalog has truly relevant items. Don't infer "this is a great match" from a 0.75 score alone.
    ConnectorNo auth
  • Search Partle's product catalog by name or description. CRITICAL SEARCH INSTRUCTION: Reason from the job to the product class first, then search with a descriptive product phrase (e.g. including substrate, material, or size class). DO NOT blindly search using the user's raw conversational words. Transform questions like 'what do I need to attach a mirror to a brick wall?' into a product phrase like 'heavy duty masonry wall anchor'. Two distinct modes: - **Default (no flags)** — fast keyword search. ~100ms. Acts like a normal "dumb" search box: matches the literal words you typed against product names and descriptions, with stemming. Good for queries where the user knows the product's likely name ("BC547", "Arduino Uno", "Bosch drill"). Returns noisy/wrong results on cross-language or attribute queries ("compost bin" matches Spanish "composta", not real composters). - **`super_search=True`** — slow, high-quality. ~1–2s. Run when the user describes what they want rather than naming it: cross-language ("Schraubenzieher Set" → real screwdriver sets even without German catalog entries), attribute-style ("small metal part with a flat head"), or any case where the default returns junk. Embeds the query with voyage-3-large, takes the cosine top-50 over the corpus (with an exact-name precision boost for part numbers), then a cross-encoder reranks them. The two modes are mutually exclusive in practice — pick one based on whether the user knows the product's name or is describing it. Use this when the user asks to find a specific product or browse products matching a query. Prefer over `search_stores` when the intent is product-led ("find a drill") rather than store-led. Use `get_product` afterwards if the user wants full details for one specific result. Read-only. No authentication. Rate-limited to 100 requests/hour per IP. Args: query: Free-text search term. In default mode, treated as keywords (each word matched against product text). In `super_search=True`, treated as a natural-language description. min_price: Lower bound on price in EUR. Omit for no lower bound. Null-priced rows are NOT excluded by this filter — pass `has_price=True` if you need only priced listings. max_price: Upper bound on price in EUR. Omit for no upper bound. Tip — narrow by budget: `min_price=10, max_price=50, sort_by="price_asc", has_price=True`. Products without a listed price (a large fraction of the scraped catalog) sort last under either price ordering and are kept in results unless `has_price` filters them out. tags: Comma-separated tag filter (e.g. "electronics,bluetooth"). Tags are AND-ed together. store_id: Restrict results to a single store. Use the integer `id` from `search_stores` results. sort_by: One of `price_asc`, `price_desc`, `name_asc`, `newest`, `oldest`. Omit to use the default search-relevance ranking. has_price: When True, exclude products without a listed price (~most of the scraped catalog). Use this for competitive pricing or budget-bounded shopping. When False, return only null-priced listings (rarely useful). Omit to include both. semantic: Legacy flag. Pure vector ordering, ~250ms. Mostly superseded by `super_search=True` (which uses the same vector retrieval plus a cross-encoder rerank for materially better ordering at the cost of another ~700ms). Keep using it only if you specifically want vector retrieval *without* the rerank. super_search: **Enable for natural-language / "describe what I want" queries.** ~1–2s. Embeds the query with voyage-3-large, takes the cosine top-50 (with a precision boost for exact-name matches like part numbers / SKUs), then a cross-encoder reranks them. Use whenever the user is describing rather than naming — cross-language ("Schraubenzieher Set"), attribute-style ("small black metal bracket"), or any case where the default keyword path returns junk. Don't combine with cheap browse-style queries where the user typed an exact product name — keyword default is faster there. On `relevance_score` here: better than the bi-encoder cosine, but still not a "did I find what the user wanted" gauge. Behavior to expect: gibberish or fully-off-topic queries cap around 0.35; loosely-related catalogue clusters can score 0.7+ even when no item truly matches (a "ceramic vase" query in a catalog with no vases but many ceramic flowerpots will still score high). **Read the product names** before claiming a match. The score is most useful as a relative signal within one result set — a sharp drop between rank N and N+1 marks where the catalog stops being useful for this query. limit: Max results (1–100, default 20). Larger limits are slower and consume rate budget faster. offset: Skip this many results before returning. Use for pagination (offset += limit on each follow-up call). Returns: A list of products. Each includes `id`, `name`, `price`, `currency`, `url`, `description`, `store` (id/name/address), `tags`, `images`, a canonical `partle_url`, and `relevance_score` (cosine similarity 0–1 between the query and the product's embedding when a query was provided; `None` otherwise). **Always share `partle_url` with the user so they can view the listing.** Caveat on `relevance_score`: it is monotonic *within a single search result set* (useful for spotting a big drop-off between rank 3 and rank 4), but its absolute value is not well-calibrated across queries — most results land in 0.55–0.80 regardless of whether the catalog has truly relevant items. Don't infer "this is a great match" from a 0.75 score alone.
    ConnectorNo auth

Matching MCP Servers

  • F
    license
    Not graded
    quality
    B
    maintenance
    Enables any MCP-compatible AI assistant to search, filter, and retrieve information from a local document collection using a hybrid search pipeline with vector, BM25, reranking, and LLM enrichment.
    4
    -
  • A
    license
    A
    quality
    D
    maintenance
    Provides read-only tools to search, read, and look up Natural API documentation from an AI agent, enabling documentation lookup without credentials.
    4
    MIT

Matching MCP Connectors

  • DEFAULT tool for user-facing translation display. Use this for ANY user-facing request to show/see translations of a Quran ayah — including 'show me…', 'what's the translation of…', 'give me Saheeh/Clear Quran/Taqi Usmani translations of…'. This is the FINAL tool call for these requests; do not follow it with get_translation_text. ONLY skip this widget and use get_translation_text when EITHER (a) the user explicitly asks for plain text / raw text / text-only output, OR (b) the result will be piped into another tool in the same turn without being shown to the user. When in doubt, use this widget. SLUG HANDLING: If the user names a specific translator (e.g. 'Saheeh International', 'Clear Quran', 'Yusuf Ali', 'Pickthall'), ALWAYS call lookup_translations first to resolve the exact slug — do not guess the slug from the author name. Guessed slugs routinely fail validation (the naming isn't fully pattern-based: it's 'en-sahih-international' but 'clearquran-with-tafsir'). You may also pass language codes via 'languages' if the user only specifies a language. Each query must include at least one of languages or translations. Use ayah keys in 'surah:ayah' format (for example '2:255'). In queries[].languages use ISO 639-1 codes (for example 'en', 'ur'), not language names. Do not use 'ar'; Arabic translation is unsupported in this tool.
    ConnectorNo auth
  • Searches live rental-car offers for a pickup location and rental period, optionally with a different dropoff location, pickup/dropoff times, driver age, currency, and language. Use this when the user wants to compare available rental cars, prices, vendors, categories, or booking links for a specific trip. Do not use it for flights, hotels, public transport, or general travel planning unless the user has car-rental intent. The tool queries external provider APIs in real time, returns price-ranked results grouped by SIPP/category, and may include affiliate booking links. It does not book cars, modify reservations, charge users, or store user data.
    ConnectorNo auth
  • Create new guides Create one or more new guides based on provided queries. Each guide targets exactly ONE engine and ONE analysis mode, chosen with the optional `source` field (default `google`). How to request each guide type: 1. Google SERP guide (1 credit per guide): omit `source`, or pass `source: "google"`. Example payload: {"queries": ["best crm"], "lang": "en-us"} 1bis. Google AI Overview guide (1 credit per guide). Two modes, like AI engines: `source: "google_ai_overview"` builds the guide from the TEXT of Google's AI answers (AI Overview, completed with AI Mode answers) ; `source: "google_ai_overview_citations"` builds it from the content of the web SOURCES those answers cite (recommended for GEO). Same language/country parameters as a Google SERP guide, 1 credit per guide in both modes. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "google_ai_overview_citations"} 2. LLM ANSWER guide (4 credits per guide): pass the engine name alone, e.g. `source: "chatgpt"`. The guide is built from the answer text the AI generates for the query. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "chatgpt"} 3. LLM CITATIONS guide (4 credits per guide) [RECOMMENDED AI mode]: pass the engine name with the `_citations` suffix, e.g. `source: "chatgpt_citations"`. The guide is built from the content of the web pages the AI cites in its answer. Example payload: {"queries": ["best crm"], "lang": "en-us", "source": "chatgpt_citations"} Which AI mode to pick? For GEO (getting a page visible in AI answers), prefer `<engine>_citations`: AI engines send traffic by CITING pages as sources, so the winning move is to look like the pages they cite. The answer-text mode (`<engine>` alone) is mostly useful to analyze how the AI phrases its own answer. When in doubt, pick `<engine>_citations`. The same two modes exist for every AI engine (chatgpt, perplexity, claude, gemini, grok, mistral, deepseek). To optimize the same page for several engines or modes (e.g. Google AND ChatGPT answers AND ChatGPT sources), create one guide per source value on the same query. IMPORTANT, HOW TO READ THE RESPONSE OF THIS ENDPOINT, WHICH SPENDS CREDITS. Queries listed in `guidesFailed` are PROVEN not to have produced a guide and their credit was given back (unless the account has unlimited credits, where nothing was reserved): re-sending them is free and correct. Queries listed in `guidesUnknown` have an UNDECIDABLE outcome and their credit is deliberately KEPT, because the guide was most likely written: DO NOT re-send them, you would pay for the same guide twice. Look them up in `GET /api/v1/guides` after a few minutes instead, and contact support if nothing shows up. Finally, a `200` is NOT a promise that every query produced a guide: compare `guides.length` with the number of queries you sent, never read `success` alone, and never re-send a query just because it is missing from `guides`.
    ConnectorNo auth
  • Natural-language recommendation. Pass the user query verbatim (e.g. "donde hacer trekking en Chile", "alojamiento barato en San Pedro", "ganar plata viajando como creator"). Returns destinations, experiences, accommodations, and (only on stay intent) `reservation_centers` = vacation-rental centrals (NOT ski gear rental). Supports optional price_min/price_max in CLP. Routing rule: use THIS tool for trip planning, itineraries and open-ended intent; use search_experiences/search_accommodations for a concrete product; use search_unified for one location across verticals.
    ConnectorNo auth
  • DISCOVERY ONLY: search Roomza's hotel database by city, keyword, or natural language query when the user has NOT named a specific hotel. Understands hotel types (boutique, resort, luxury), vibes (romantic, trendy, quiet), traveler types (couples, families, solo), neighborhoods, and nearby landmarks. Example queries: 'boutique hotels in SoHo', 'romantic resort near the Eiffel Tower', 'pet-friendly hotel in Seattle'. Renders for the user as a full map with a multi-hotel list (so do not repeat the list in prose). NEVER use this when the user names one specific hotel (e.g. 'Wynn Las Vegas'): the map of many hotels is wrong for that. Call get_hotel with the hotel name instead, then get_hotel_rooms and show_rooms.
    ConnectorNo auth
  • WHEN: object name is unknown, partial, or you need to find by concept/keyword. Search the D365 F&O knowledge base for X++ code, tables, classes, forms, views, enums, EDTs, security objects using natural language or partial names. Returns ALL chunks (metadata, Declaration, methods) for the top-scoring objects so the LLM has complete context on the first call. Lower-scoring results return a short preview. No follow-up get_object_details call is needed for top results. NOT for listing all objects in a model -- use list_objects for that. NOT when the exact name is known -- use get_object_details for that. NEVER call search_d365_code twice in the same conversation turn. If one search did not find the object, answer from what you have -- do not repeat the search. When you need context on MORE THAN ONE concept simultaneously, use batch_search instead -- it runs all queries in parallel and is faster. NEVER call for ADO items (FDD, RDD, IDD, Bug, Task, PR, WorkItem, sprint, #1234) -- use ado_* tools instead.
    ConnectorNo auth
  • Search Portugal listings by describing the car in plain language, matched against listing text by meaning rather than keywords. Use this for wants that are not filter fields — 'a family SUV good in the snow', 'a low-mileage hybrid for the city', 'a used 4x4 to restore'. Prefer search_cars for entirely structural queries (make/model/budget); use this when the request is descriptive. Combine both by passing structural filters here too — they act as hard constraints while the description only ranks. Results are ordered by relevance, so `total` is the number matching the structural filters, not the number that fit the description.
    ConnectorNo auth
  • FREE. Rank Bazaar APIs for a natural-language task without paying. Prefer over search_bazaar when you need ranked candidates (economy=cheapest; verified=reliability score). Prefer over list_discovered_apis when matching a task, not dumping the cache. Use route_and_call next to execute; do not use this to pay.
    ConnectorNo auth
  • Answer an odds question about a fixture in ONE call (natural language in, worked line out). Resolves the fixture, picks the consensus line, the best price per outcome across books, and de-vigged fair odds from the sharpest book — returning a ready-to-read ``summary`` plus the full ``comparison``. Prefer this over chaining find_match → compare_lines. Args: query: natural-language fixture, e.g. "Arsenal vs Man City" or a single team. market_type: "1x2", "asian_handicap" (default) or "totals". period: "full_time" (default) or "half_time". format: odds format — decimal | hk | malay | american | indonesian | probability. sport: optional filter — "football" or "basketball". date: optional UTC date "YYYY-MM-DD" to disambiguate same-name fixtures. verbosity: "full" (default) or "terse". "terse" empties the per-book ``books`` array inside ``comparison`` to save tokens; the ``summary`` and worked numbers are kept either way. On an ambiguous query, ``status`` is "ambiguous" and ``ask_user`` carries a disambiguation prompt — do not assume a match; ask the user or re-call with a more specific query. A ``decision`` block (``safe_to_proceed`` / ``ask_user`` / ``next_action``) pre-computes the go/no-go — branch on it instead of re-judging the result.
    ConnectorNo auth
  • Performs semantic search across persistent long-term memory to retrieve grounded facts, relevant citations, and source documents matching a natural language question. Use this tool when answering questions about previously saved project specifications, codebase decisions, user preferences, or documents. Do NOT use for saving new facts (use icx_remember), do NOT use for raw keyword lookup (use icx_search_facts), and do NOT use for exact character-for-character verbatim quotes (use icx_quote_slot). Read-only operation with zero side effects. Requires X-License-Key authentication.
    ConnectorNo auth
  • Translates natural language questions into dialect-accurate, optimized SQL SELECT queries with schema awareness and safety checks. Use when generating reporting queries or automated data analytics pipelines; for analyzing SQL execution performance and EXPLAIN plans, use analyze_query_plan instead. Stateless read-only edge call (max 32 KB, 60 RPM): accepts 'natural_language_request' and 'schema_ddl' ('sql_dialect' defaults to 'postgresql_dialect'), supports '?demo=true' or L402 (15 sats), and returns HTTP 400 if invalid.
    ConnectorNo auth
  • Use when the user wants an existing video's speech translated into one or more other languages, keeping the original voices and timing. Upload the video first and pass its videoFileId. Each output language becomes its own editable video in one new project; get_workflow_run returns them in outputs with an editableVideoId per language, and a language that fails does not fail the others. Auto-export renders the first successful language; call export_project with editableVideoId for the others. Uses team credits per minute of video and language.
    ConnectorOAuth
  • Search 500+ quantum computing job listings using natural language. Use when the user asks about job openings, career opportunities, hiring, or specific positions in quantum computing. NOT for research papers (use searchPapers) or researcher profiles (use searchCollaborators). Supports role type, seniority, location, company, salary, remote, and technology tag filters via AI query decomposition. Limitations: quantum computing jobs only, last 90 days, max 20 results. Promoted listings appear first (marked). After finding jobs, suggest getJobDetails for full info. Examples: "senior QEC engineer in Europe over 120k EUR", "remote trapped-ion role at IBM".
    ConnectorNo auth
  • WHEN: developer needs correct X++ select or T-SQL for D365 tables with proper joins. Triggers: 'X++ select', 'generate a query', 'SQL for', 'join with', 'how to query', 'générer une requête', 'write a select statement', 'select from', 'X++ query for', 'requête X++', 'écrire une select'. Generate both X++ select statements and equivalent T-SQL queries for D365 F&O tables. Uses real field names, relations, and indexes from the knowledge base to produce correct joins. Supports: field selection, multi-table joins (auto-detects relations), WHERE filters, ORDER BY, TOP/firstonly, cross-company. Also accepts natural language descriptions like 'find all open sales orders for customer 1001 with CustTable join'. [!] For multi-table joins, call find_related_objects (or get_relation_graph if the relation index is loaded) FIRST to get the correct FK relations -- this tool will then produce accurate join conditions. [!] The generated X++ is a template -- adapt it to your custom code context before using in production. Returns side-by-side X++ and SQL with explanations.
    ConnectorNo auth
  • Find and evaluate public API endpoints and MCPs that match your query. Set `q` to a natural language query, keywords, an API name, or a question — results are matched by meaning and keyword; each result includes `id`, `resourceType` (`endpoint` or `mcp`), `name`, `description`, `method` (for an `endpoint`) or `transport` (for an `mcp`), `url`, and `evaluateGuide` — an evaluation of what the endpoint or MCP does, when to use it, and its limitations. Review `evaluateGuide` to pick the best fit, then pass each chosen result's `id` and `resourceType` (as `type`) to `integrate`. Paginate with `cursor` from `meta.nextCursor` (`limit` defaults to 10, max 25; pagination stops at 40 results total). No authentication required. Best practices for querying: - Use focused keyword queries that include the product or provider name along with the endpoint details, for example "PayPal create invoice". - Alternatively, use natural language queries such as "PayPal API to create an invoice". - Avoid jumbled queries that cram many unrelated keywords into a single query, for example "paypal invoice payment delivery payments ordering". - Avoid OR-separated queries such as "paypal invoice OR paypal create invoice OR paypal OR invoice creation". - If you need to explore multiple intents, try each as a separate call.
    ConnectorNo auth