Felt MCP

List tables and saved queries inside a connected database. Returns table names and descriptions: but not column schemas.

List Felt's curated public datasets to add to maps. Categories include boundaries, demographics, and infrastructure. Distinct from the workspace library (reusable layers authored in the user's workspace). Returns each layer's layer_id, layer_group_id, name, description, category, region, keywords, geometry type, and whether it's queryable.

Show the contents of a Felt Server: a named, foldered library of reusable layers in this workspace. Returns layers and layer groups (groups of related layers that share metadata), nested under their containing folders.

Create a new map layer from a SQL query against a connected data source. The query must include a location/geometry column so the results can be rendered on the map. Before calling this, you MUST confirm the exact column names and types of every table you plan to query, and review the SQL dialect guidance for the data source. Don't guess columns or discover them with preview SELECTs.

Create a new map layer from a SQL query against Felt layers. The query must include a location/geometry column so the results can be rendered on the map. Before calling this, you MUST confirm the exact column names and types of every layer you plan to query, and review the SQL dialect guidance. Don't guess columns or discover them with preview SELECTs.

Delete an annotation from a map.

Delete a layer from a map.

Generate FSL (Felt Style Language) JSON for styling any map layer type. Supports all layer types (points, lines, polygons, rasters, heatmaps, H3 hexbins) and all styling features (colors, classification, labels, popups, filters, icons). When provided with a layer ID, inspects the layer's data directly: value distribution, histograms, classification breaks, categories, and raster band info: to make informed styling decisions.

Get a layer group's name, caption, legend settings, and its layers. Only works on real layer groups, not on standalone layers.

Get a layer's properties including its name, caption, geometry type, and current FSL style. Use this to retrieve a layer's current style before modifying it.

Get the list of layers on a map, organized by layer group. Returns layer names, IDs, visibility, and geometry types. Groups and their layers are listed in visual stacking order, topmost first; groups with `standalone: true` are top-level layers, not user-visible groups.

Get details about a project, including the maps it contains.

Execute a read-only SQL query against a connected data source and return tabular results. Use fully schema-qualified table names. The query must be a SELECT statement. Results are returned to the user as rows and columns: this does not render anything on the map. Before calling this, you MUST confirm the exact column names and types of every table you plan to query, and review the SQL dialect guidance for the data source. Don't guess columns or discover them with preview SELECTs.

Answer any question about how Felt works, from Felt's official and current help center documentation. Use this whenever someone wants to know how to do something in Felt themselves ("…in the app", "where is the button for…"), and whenever nothing in your toolset covers what they need: billing, seats and licenses, workspace and member administration, and account settings have no tool here. No map or workspace needed. Prefer this over your own knowledge: Felt ships continuously, so what you learned in training goes stale. If the docs don't cover something it says so rather than inventing an answer, so call it instead of guessing, hedging, or sending the user off to read the docs themselves. Your own tools come first, though: if you can just do what they asked, do that; even "how do I create a map?" is usually best answered by offering to create one. For the contents of a specific map or dataset, use get_map, inspect_layer, or the tabular data tools instead.

Get the full column schema for a table in a connected database, including column names and types.

Get the details of a single layer: the full column schema (column names, types, sample values, row count, cardinality, min/max for numeric columns), whether the layer is visible, and its legend items (categories or class breaks) with the ids set_visibility expects. Returns a table name for queryable layers that can be used as the table identifier in SQL queries. `processing_status` says whether the schema below can be trusted: - `completed`: an empty `columns` list means the layer really has no attributes. - `processing`: the layer is still being built, so its columns and row count are missing or provisional. `progress_percent` says how far along, when the pipeline reports it. - `failed`: the import failed and `processing_error` says why. Every column reports two names. Which one applies is fixed per use, so route by this list rather than by which name reads better: - `storage_name`: the attribute of an FSL style, and the group_by, aggregate_by and filter_by bindings of a layer component. This is the name the data itself carries, and it can be an opaque UUID for a column added by editing the layer. - `display_name`: a SQL query against this layer's table, the columns edit_layer_attributes names, and any title or wording you write for the user, including a layer component's title. This is the name Felt shows in its own UI. A layer component therefore takes both: its title is the display name, its attribute binding is the storage name. A style that renames a column makes the two names unrelated strings, so neither can be derived from the other: read both from this tool. A layer's features and columns can be edited by collaborators between turns, so treat results as a snapshot and re-inspect when correctness matters.

Return all lightweight markup annotations on a map. Only includes annotation types this tool family can edit: `Place`, `Rectangle`, `Polygon`, `Circle`, `Text`, `Note`, `Link`, `Line`. Other annotation types drawn in the UI are excluded but still exist on the map: mention that to the user if they ask why something is missing. Each returned annotation is shaped to pass straight back to `upsert_annotations` (modify by its `id`). Geometry conventions: every coordinate is `[latitude, longitude]`, the reverse of the `[longitude, latitude]` order that SQL and GeoJSON expect. Per type: - `Place`: `coordinates` is one point. - `Circle`: `center` and `radius` in meters. No polygon is returned; construct one if you need an area. - `Rectangle`: `corners` is the south-west corner then the north-east corner of an axis-aligned box. - `Polygon`: `coordinates` is the outer ring, left open: the first vertex is not repeated at the end. No holes. - `Line`: `coordinates` is an ordered list of vertices forming a single polyline. - `Text`, `Note`, `Link`: `corners` is the box the label occupies on screen. It is not a claim about an area on the ground; don't use it as one. Annotations are markup, not data: for circling, labelling, sketching and pointing things out. If the geometry comes from a query or a file, traces a real boundary, or runs to more than a handful of shapes, create a layer instead.

List connected external databases (Postgres, Snowflake, BigQuery, etc.). Returns source names, IDs, and database types. The type indicates the SQL dialect to use when querying.

List maps the current user can access. Returns the most recently visited maps.

Wait until a layer is ready to use. Polls the layer's processing status until it resolves or `wait_seconds` elapses. `wait_seconds` is one of `5`, `10`, or `30`. Pick `5` for a quick check before moving on; pick `30` when waiting for processing is better UX than an idle back-and-forth. The call returns early if the status resolves sooner. Returns `status`, one of: - `in_progress`: layer is still processing; call this tool again. - `completed`: layer is ready. - `failed`: processing failed. An `error` field explains why. An `error_type` field (when present) gives the exception class name.

Returns a presigned upload slot for adding a file to Felt as a new layer on the map. The layer is created once you POST the file bytes to the returned slot: this tool alone does nothing visible until the upload completes. Requires code execution (shell / HTTP client) to complete. Supported formats: CSV, TSV, Excel, GeoJSON, Shapefile ZIP, KML, KMZ, GPX, MBTiles, FlatGeobuf, GeoPackage, DXF, DWG, GeoTIFF, and any other raster format that GDAL supports. Felt will reproject data into the correct coordinate system if spatial referencing is defined in the format metadata: DON'T reproject. Felt detects and geocodes addresses and common location columns (lat/lon, admin boundaries, H3, WKT) automatically. When narrating progress to the user, describe this as "uploading to Felt": never as uploading to S3 or naming any backend storage service. Felt's storage is an implementation detail; some customers also connect their own S3 buckets to Felt and naming the backend confuses where their data is going. Use this when: you can execute code (shell, HTTP client) and need to upload a local file: large or binary files, or text files you'd rather not inline. This is the paved road for file uploads. Don't use this when: the file is at a public URL (use `import_layer_from_url`), the content is small text already inline in your conversation (use `upload_contents_to_map`), or you cannot execute code. Without code execution, direct the user to their map's URL (from `get_map` / `list_maps`) and ask them to drag-and-drop the file into the Felt web app: do not call this tool. Provide `replace_layer_id` to refresh an existing file-backed layer with the uploaded bytes instead of creating a new one. Omit it to create a new layer. How to use the returned slot: Build a multipart POST using every entry in `upload.form_fields` exactly as returned: don't reorder, modify, or re-sign. Add one more part named `upload.file_field_name` with the file bytes and filename `upload.filename_to_send`. POST to `upload.url`. Treat `upload.expected_status` (204) as success; any other status means the slot is bad: don't retry, call `prepare_file_upload` again for a fresh slot. On 204, call `poll_layer_processing_status` with the returned `map_id` and `layer_id` to confirm processing. Trust the HTTP status of your upload POST to know whether the bytes landed. If the POST returned 2xx, poll until `completed` or `failed`. If the POST returned 4xx/5xx, the slot is bad: request a new one via `prepare_file_upload`.

Refresh a data-source-backed layer in place. Re-runs its stored query or re-reads its backing table. Use this when: the user wants the latest data for a layer backed by a connected data source. Processing is asynchronous; use the returned `map_id` and `layer_id` to poll the layer's processing status.

Render a Felt map inline as an interactive widget for the user. For map metadata (title, location, layer count, etc.) call `get_map` instead: `render_map` is solely for showing the user the map. The widget captures a one-shot snapshot of the map's state at the moment this tool is called and does NOT update live as you make further changes: call `render_map` LAST in any turn that creates or edits a map so the user sees the final state. If you added or imported layers in this turn, first call `poll_layer_processing_status` and wait for them to finish processing; rendering before that point shows an empty or incomplete map. ALWAYS pair this call with the map's URL in your text reply: include the returned `url` as a clickable markdown link (e.g. `[<map title>](<url>)`). The widget is a snapshot users can't navigate from: the link is how they actually open the map in Felt, so calling `render_map` is not a substitute for sharing the URL.

Set how a layer group's layers are toggled in the legend. Options: - default: a checkbox list: each layer toggles independently. - slider: a slider that steps through layers, one visible at a time (best for ordered series like time steps or scenarios). - single_select: a radio/dropdown: exactly one layer visible at a time. - multi_select: checkboxes where any combination of layers can be visible. Layer group ids come from get_map_layers. slider, single_select, and multi_select require a group with at least two layers. Switching to slider or single_select leaves only the top layer visible; switching to default or multi_select makes every layer visible.

Update a map's public access setting and return its share URL.

Update a layer group's name, caption, or legend settings. Only the provided fields change. Only works on real layer groups, not on standalone layers.

Update a layer's properties. Can set any combination of: FSL style, name, caption. Only the provided fields are changed; omitted fields are left as-is.

Add Geo data to the map as a new layer by including its contents inline as raw text (no file upload). Supported formats: CSV, TSV, GeoJSON, KML, GPX. Use this when: the content is already inline in your conversation (e.g., the user dragged a small CSV into Claude) and you cannot run a shell command. Don't use this when: you have code execution (prefer `prepare_file_upload`: bytes flow directly to Felt without passing through conversation context), the file is at a public URL (use `import_layer_from_url`), or the content is a larger or binary file (use `prepare_file_upload`). ## Check the size before calling You retype every byte of `contents` yourself, so a large paste costs minutes of generation and can exhaust your output budget part-way through, which kills the turn and produces no layer at all. Judge the size of the data before you call. Above roughly 200 rows or 20 KB of text, use `prepare_file_upload` instead: it sends the bytes directly without passing them through your output. Never call this tool with a shortened, sampled, or partial copy of the data. When you are unsure whether it is too big, prefer `prepare_file_upload`. ## Felt infers location from the contents: you do not need coordinates Felt works through these in order and stops at the first that resolves for most rows: 1. Geometry literals: a WKT, WKB, EWKB, or GeoJSON column (named `wkt`, `wkb`, `geojson`, `geometry`, `geom`, `the_geom`, `geography`, `shape`, or `location`), or a coordinate pair: `longitude`/`latitude`, `lng`/`lat`, `lon`/`lat`, `long`/`lat`, or `x`/`y`, including prefixed and suffixed variants like `pickup_lon`/`pickup_lat`. 2. Addresses, which Felt geocodes: either one full-address column, or separate street / city / region / country / postal-code columns. 3. Well-known entities, matched by name or code: countries (name, ISO2, ISO3); admin-1 regions (name, local name, ISO 3166-2); US states (name, USPS abbreviation, FIPS); US counties, CBSAs, census tracts, and block groups (name and/or FIPS GEOID); US ZIP codes and ZCTAs; Eurostat NUTS 1/2/3 and LAU (name and id); Australian postal areas; and IANA time zone names. 4. H3 cell ids. Pass the location column through as-is: never convert an address or an entity name to coordinates yourself, and never drop a column you think Felt can't read. Guessing coordinates produces a layer that looks authoritative and is wrong; Felt's geocoder and entity matcher are the correct answer. Name location columns for what they hold (`county_fips`, `zip`, `country`, `h3`, `lat`/`lon`). Detection reads column names as well as values, so a well-named column matches far more reliably. Entity matching needs most values in the column to resolve, so keep the rows in one consistent form rather than mixing, say, county names with state names. ## When the user supplied the text, pass it through verbatim The column guidance above applies only to data you are composing yourself. When the user pasted or typed the data, set `format` to what they actually gave you: `tsv` for tab-separated text, `csv` for comma-separated: and copy the text through unchanged. Never convert between formats, re-delimit columns, rename or reorder columns, or reflow rows. Write the data exactly once, as this argument. Restating the rows in your reasoning or drafting them as a table first doubles the cost and can exhaust the turn before the upload begins. Provide `replace_layer_id` to refresh that uploaded layer with the supplied contents instead of creating a new one. Does not work on layers backed by a connected data source. Omit it to create a new layer. Processing is asynchronous; call `poll_layer_processing_status` with the returned `map_id` and `layer_id` to confirm completion.

Create or update lightweight markup annotations on a map: pins, notes, sketched shapes and lines. Supported types: `Place` (pin), `Rectangle`, `Polygon` (arbitrary outline), `Circle`, `Text`, `Note` (callout), `Link` (clickable preview that opens a URL), `Line` (polyline). Each annotation is an independent item. Coordinates are `[latitude, longitude]`. To create: omit `id` and supply `type` + the type's required fields. To update: supply `id` AND `type` (always required) plus any fields you want to change; fields you omit are preserved. The response returns a `results` list in the same order as your input, each entry with an `id` and `status` (`"created"` or `"updated"`), so you can zip it against what you sent. Annotations are markup, not data: for circling, labelling, sketching and pointing things out. If the geometry comes from a query or a file, traces a real boundary, or runs to more than a handful of shapes, create a layer instead.