Skip to main content
Glama
va-lis-mcp

va-lis-mcp

by JonnyWaffles

va-lis-mcp

An MCP server for the Virginia Legislative Information System (LIS) REST API. It exposes the Virginia General Assembly's sessions, bills and keyword search, summaries, full bill text and versions, action history, votes and roll calls, members, committees, meetings, minutes books, communications between the chambers, and session statistics to any MCP client (Claude Code, Claude Desktop, and others). Every tool is read only. You bring your own LIS API key.

Built on va-lis-client, a Python client for the LIS API.

Requirements

  • Python 3.10 or newer

  • uv, which provides the uvx launcher used below. Install it with one line: curl -LsSf https://astral.sh/uv/install.sh | sh (macOS/Linux) or powershell -c "irm https://astral.sh/uv/install.ps1 | iex" (Windows)

  • A LIS API key (next section)

Related MCP server: legiscan

Getting an API key

Register for a free partner key at https://lis.virginia.gov/apiregistration. The key is a GUID. The server reads it from the LIS_API_KEY environment variable.

LIS heartbeat endpoints accept any key, even garbage, so a successful ping proves nothing. Use the check_api_key tool to confirm the key is registered and active.

Install and configure

Claude Code

claude mcp add va-lis -e LIS_API_KEY=your-guid-here -- uvx va-lis-mcp

Claude Desktop and other MCP clients

Add this to the client's MCP configuration (for Claude Desktop that is claude_desktop_config.json):

{
  "mcpServers": {
    "va-lis": {
      "command": "uvx",
      "args": ["va-lis-mcp"],
      "env": { "LIS_API_KEY": "your-guid-here" }
    }
  }
}

Installing from source

To run the server from a checkout, point the client at it instead:

git clone https://github.com/JonnyWaffles/va-lis-mcp
claude mcp add va-lis -e LIS_API_KEY=your-guid-here -- uv run --directory /path/to/va-lis-mcp va-lis-mcp

The same works in a JSON config with "command": "uv" and "args": ["run", "--directory", "/path/to/va-lis-mcp", "va-lis-mcp"].

Tools

Every tool returns compact JSON. Bills are addressed by bill number plus session code, members by member_id, and committees by number (H08) or name.

Sessions and bills

Tool

Inputs

Returns

get_current_session

none

The GA's working session, with a note on what "current" means during the interim

list_sessions

year

Sessions for a calendar year with their codes (reference data reaches back to 1994)

get_session

session_code

One session with its milestone dates: prefiling, convening, adjournment, and the reconvened session

list_bills

session_code, query?, limit?, offset?

Bill rows filtered by a substring match on number, description, and title; paginated, with a total match count

search_bills

session_code, keyword?, search_in?, category?, member_id?, chapter?, chamber?, include_summaries?, limit?, offset?

Full text search over summaries or bill text, with filters for the stage a bill reached, a patron, and an Acts of Assembly chapter number; one row per bill with status, chapter, committee, and chief patron

list_most_viewed_bills

session_code, limit?

The bills readers of the LIS website open most often, at most 100

list_amended_bills

session_code, amended_by?, query?, limit?, offset?

Every bill that carries an amendment, with each amendment's document code, chamber, and disposition; paginated

list_conference_bills

session_code, chamber?, member_id?, limit?, offset?

The bills that went to a conference committee, for the session or for one conferee; paginated

get_bill

bill_number, session_code

Full bill detail: title, status, dates, patrons grouped by role, and the session lineage list

get_bill_patrons

bill_number, session_code

Every patron with member id, role, and chamber, in LIS display order

get_bill_summaries

bill_number, session_code

Plain text summaries (as introduced, as passed); the active entry is the current one

get_bill_text

bill_number, session_code, document_code?

Plain text of one version (default: most recent), truncated at 15,000 characters, plus the list of available versions

get_bill_versions

bill_number, session_code

Every published version with its chamber, sponsor, and disposition, and the links to its PDF, HTML, and fiscal impact statements

get_bill_history

bill_number, session_code

Chronological events with date, description, actor, committee, vote tally, vote_id, status, and passage flags

Votes

Tool

Inputs

Returns

get_bill_votes

bill_number, session_code

Every vote the bill saw in either chamber (floor, committee, subcommittee) with tally, outcome, and the voice, block, and roll call flags

get_bill_vote_tallies

bill_number, session_code

The same votes in two requests: tallies and no members, with most voice votes missing

list_votes

chamber, session_code, start_date, end_date?, limit?, offset?

Every vote one chamber took in a date range, with the bill and the tally; paginated

get_roll_call

bill_number, session_code, vote_id?

Members grouped as yea, nay, abstain, and not voting, each with party and district, plus any vote statements; voice and block votes are left out

get_member_votes

member_id, session_code, bill_number?, exclude_block_votes?, limit?, offset?

One member's votes across a session or on one bill, with block votes flagged; paginated

Members

Tool

Inputs

Returns

list_members

session_code, query?, chamber?, party?

The session roster, searchable by any part of a name, departed members included

get_member

member_id, session_code

One roster record with party, district, status, and contact details

get_member_office

member_id

The member's district office: postal address, phone, and email, when LIS holds one

get_member_bills

member_id, session_code, role?, query?, limit?, offset?

Every bill the member patrons, with chief patronage flagged; paginated

get_member_committees

member_id, session_code, include_subcommittees?

The member's committee seats and roles

Committees

Tool

Inputs

Returns

list_committees

chamber?, include_subcommittees?

The standing committees, with subcommittees on request

get_committee

committee, session_code, chamber?

The committee's roster for the session with each member's role, party, and district, its regular meeting note, and its subcommittees

get_committee_staff

committee, chamber?

The clerks and staff who serve the committee, with the date each assignment began

Meetings

Tool

Inputs

Returns

list_meetings

start_date, end_date, committee?, chamber?, meeting_type?, limit?, offset?

The master schedule for a date range: date, the clerk's time text, room, owner, and cancellation flag; paginated

list_dockets

committee, session_code

A Senate committee's dockets with the bills on each (the House keeps none)

list_floor_calendars

chamber, session_code

A chamber's floor calendars for the session

get_floor_calendar

calendar_id

The bills on one floor calendar by section, with the actions and vote ids recorded against each

Chamber records

Tool

Inputs

Returns

list_minutes_books

session_code, committee?, chamber?, kind?, start_date?, end_date?, limit?, offset?

The published minutes books of a session, newest first, with floor books marked; paginated

get_minutes_book

minutes_book_id, include_procedural?, limit?, offset?

Each action a chamber or committee took that day, with the bill, the tally, and a vote_id that belongs to that bill; paginated

list_communications

session_code, chamber?, limit?, offset?

The messages the two chambers sent each other, newest first; paginated

get_communication

communication_id

One communication: each statement of the clerk and the bills it names

Statistics

Tool

Inputs

Returns

get_session_statistics

session_code

LIS's own bill counts by chamber of origin and legislation type: introduced, passed, failed, continued, and more

get_committee_statistics

chamber, session_code

LIS's own referral counts for each standing committee, split by the bill's chamber of origin

Diagnostics

Tool

Inputs

Returns

check_api_key

none

Whether the configured key is registered and active

Errors come back as readable tool errors. A bill lookup that misses names the bill and session it searched; an ambiguous committee name lists the matches; an unknown member id points at list_members; a missing key tells you to set LIS_API_KEY and where to register.

Domain notes

Distilled from the va-lis-client documentation, which is the full reference for LIS behavior.

  • Session codes encode year plus sequence: 20261 is the 2026 Regular Session, 20262 is 2026 Special Session I. Most tools require one.

  • Bill numbers are unpadded. LIS returns nothing for HB0001; the correct form is HB1. The tools normalize input (hb0001 becomes HB1), so you can pass either.

  • The default session tracks the GA's working session. Once a session wraps up, the default advances to the upcoming session during the interim. By August 2026 it already pointed at 20271. For retrospective work on a session that just ended, pass its explicit session code.

  • Carry over reuses bill IDs. A bill from an even year session may be carried over into the following odd year session (never the reverse, at most once). The carried bill keeps its numeric LegislationID in both sessions, so a bill is identified by session code plus bill number. The sessions list on get_bill is the lineage record: two entries mean the bill was carried over.

  • Passage dates live in the history. The bill detail's passage date fields are always null in LIS; get_bill_history flags passage events and carries the vote tallies.

  • Votes reach a bill through its history. No LIS vote endpoint accepts a bill id, so get_bill_votes walks the bill's events and fetches the vote behind each one. get_bill_history carries the vote_id on each event.

  • A block vote is not a position on one bill. A chamber bundles its uncontroversial bills and passes them in one motion; one 2026 House vote disposed of 105 bills at 97 to 0. A voice vote records no members at all. get_roll_call leaves both out, get_bill_votes flags them, and get_member_votes marks each row with is_block.

  • Not voting is not in the tally. Members recorded as not_voting (LIS code X) are omitted from the tally string, so the member groups never add up to it. Vote statements are corrections a member filed afterwards; the recorded roll call is never amended.

  • The roster is larger than the chamber, on purpose. A session roster includes members who left or arrived mid-session, because they cast the votes recorded before they left. list_members keeps them and marks the departure date and reason.

  • Committees are not session scoped; their seats are. The committee list describes the committees that exist now, and get_committee reads the seat list for the session you name. LIS has no "bills referred to a committee" endpoint; get_bill_history names the committee that holds a bill.

  • Dockets are Senate only. House committee agendas are not in the API: list_meetings gives the meeting, the bill's history gives the referral, and the agenda itself lives on the committee's web page. Schedule times are free text as the clerk entered them and may be blank.

  • Two ways to find a bill. list_bills matches the number and the short description of every bill in a session. search_bills is the full text search over summaries or bill text. LIS drops common words from a keyword, so a word such as "the" finds nothing.

  • A filtered search hides failed bills. A keyword search on its own includes them. Once the search names a stage or a patron, LIS leaves out failed and incorporated bills (measured in October 2026). The tool matches the chamber itself for that reason, and the response says so when the gap applies.

  • A minutes book is the safe way in to a roll call. A vote_id on a bill's history can point at a vote that disposed of some other bill. A vote_id in get_minutes_book belongs to the bill beside it. The minutes tally also keeps a presiding officer's tiebreak, which the vote record drops.

  • Only the Senate publishes floor minutes. Both chambers publish committee books. For House floor action, read list_floor_calendars and get_bill_history.

  • A communication names bills, never votes. It is the formal message one chamber's clerk sends the other. Structured content starts in May 2024; an older communication is an HTML file and nothing more.

  • The fast vote list knows less. get_bill_vote_tallies and list_votes cost one request per chamber, however many votes there are. They leave out most voice votes, carry no pass or fail flag, and do not say how many bills a block vote covered. get_bill_votes has all three.

  • LIS's statistics are its own arithmetic. The session and committee counts name no bill, and they do not always agree with the bill list. A total can miss by a bill, and the committee counts are referrals, not bills. Count from list_bills when a number has to be exact.

  • Staff and offices are not session scoped. get_committee_staff names who serves a committee now. get_member_office reads the district office, and many members have none on record.

Embedding in an ASGI app

Besides stdio, the server can be served over streamable HTTP. The packaged ASGI app is stateless and returns plain JSON, so it works behind multiple workers without sticky sessions:

uvicorn va_lis_mcp.asgi:app --workers 4

The MCP endpoint is at /mcp. To mount it inside a larger Starlette (or any ASGI) application, the host app's lifespan must run the MCP session manager:

from contextlib import asynccontextmanager

from starlette.applications import Starlette
from starlette.routing import Mount

from va_lis_mcp.server import mcp


@asynccontextmanager
async def lifespan(app):
    async with mcp.session_manager.run():
        yield


app = Starlette(
    routes=[
        Mount("/lis", app=mcp.streamable_http_app(stateless_http=True, json_response=True)),
    ],
    lifespan=lifespan,
)

That serves the endpoint at /lis/mcp. Keep stateless_http=True whenever more than one worker handles requests: the default stateful transport needs every request of a session to reach the same worker, which a plain worker pool does not guarantee.

This is ASGI only; a WSGI stack cannot host it. Django projects can still serve it, but through their ASGI entry point (for example gunicorn with uvicorn workers), not through WSGI.

Development

uv venv
uv pip install -e ".[dev]"
uv run pytest
uv run ruff check .

Poke at the tools interactively with the MCP Inspector:

npx @modelcontextprotocol/inspector uv run va-lis-mcp

Upgrading

uvx caches resolved environments, so after a new release force resolution of the latest version:

uvx va-lis-mcp@latest

License

MIT

Available Tools

38 tools
check_api_keyA

Validate the configured LIS API key.

LIS heartbeat endpoints accept any key, so this is the only real check: it asks the PartnerAuthentication service whether the key is registered and active.

Inputs: no named parameters. Returns: object

get_billA

Full detail for one bill: title, status, dates, patrons, session lineage.

patrons groups member names by role (Chief Patron, Co-Patron, ...); get_bill_patrons returns the same list with member ids. sessions lists every session the bill appears in; two entries mean it was carried over from the even-year session into the odd-year session.

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_historyA

Chronological action history for a bill, from prefiling to governor action.

Passage dates live here (the bill detail's passage date fields are always null in LIS): look for events with is_passage true and read date and vote_tally. is_passage marks the events whose resulting status is a passage status (Passed House, Passed Senate, ...). status is the bill's status after each event. committee names the committee that acted; this is the only place LIS records which committee holds a bill. vote_id links an event to its vote: pass it to get_roll_call.

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_patronsA

Every patron of a bill with their member ids, in LIS display order.

role is Chief Patron, Chief Co-Patron, or Co-Patron. member_id chains into get_member, get_member_bills, get_member_votes, and get_member_committees. get_bill lists the same names grouped by role, without ids.

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_summariesB

Plain-text summaries of a bill (as introduced, as passed, ...).

The entry with is_active true is the current summary. An empty list means LIS has published no summary for that bill and session.

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_textA

Full text of one bill version, HTML stripped to plain text.

document_code selects a version (e.g. "HB1" = introduced, "HB1ER" = enrolled); the default is the most recent version. available_versions lists every version that can be requested. Long texts are cut at 15,000 characters with truncated set true. Amendment markup (additions and strikethrough deletions) is flattened to plain text.

Inputs: bill_number (required), session_code (required), document_code.

get_bill_versionsA

Every published version of a bill, oldest first, with links to its files.

Introduced, each substitute and amendment, engrossed, enrolled, and chaptered. Each version carries the address of its pdf and html file and of any fiscal impact_statements. chamber is the chamber that made the version, not the bill's: a Senate substitute for a House bill says S. sponsor is who offered it (House, Senate, Committee, Conference, Governor, Member) and disposition what became of it (Offered, Adopted, Rejected, Posted). Pass a document_code to get_bill_text to read that version. A chaptered version's code is its chapter number (CHAP0350).

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_votesA

Every recorded vote on a bill, in both chambers, in chronological order.

Floor, committee, and subcommittee votes all appear. is_roll_call is true when the recorded members voted on this bill alone; it is false for a voice vote (no members recorded) and for a block vote (one motion that disposed of bills_in_vote bills at once, which is not a position on any one of them). Pass a vote_id to get_roll_call for the member by member record. Costs one request per vote; get_bill_vote_tallies lists the tallies in two requests when the flags are not needed.

Inputs: bill_number (required), session_code (required). Returns: object

get_bill_vote_talliesA

A bill's votes with their tallies and no members, in two requests.

The fast route to how a bill fared at each stage: committee, subcommittee, and floor votes from both chambers, oldest first. It is lighter than get_bill_votes and it knows less. Most voice votes are missing, there is no pass or fail flag (read description and tally), and a block vote does not say how many bills it covered. An empty list can mean the bill was decided by voice votes alone. referred_to names the committee a vote sent the bill on to. Pass a vote_id to get_roll_call for the members.

Inputs: bill_number (required), session_code (required). Returns: object

get_committeeA

A committee's roster for a session: each member's role, party, and district.

committee is a number ("H08", "S13") or any part of a name ("Courts of Justice", "courts"). Both chambers have some names, so pass chamber or the number when a name is ambiguous. Seats come back in LIS order, chair first. meeting_note is the committee's regular meeting time when LIS records one, and subcommittees lists the subcommittees, which this tool accepts by number too.

Inputs: committee (required), session_code (required), chamber. Returns: object

get_committee_staffA

The clerks and staff who serve a committee.

committee is a number ("H08", "S13") or any part of a name; pass chamber or the number when both chambers use the name. role is Committee Clerk or Committee Staff, the Division of Legislative Services staff assigned to the committee. The list is not session scoped: it names who serves now, and since is when each assignment began. LIS sends no phone number or email for staff.

Inputs: committee (required), chamber. Returns: object

get_committee_statisticsA

LIS's own referral counts for each standing committee of one chamber.

house_bills and senate_bills split each count by the bill's chamber of origin, so senate_bills on a House committee counts the Senate bills sent to it after crossover. The counts are referrals, not bills, and the columns do not add up: failed counts only what the committee itself killed, and in_subcommittee is a part of in_committee. Subcommittees have no rows. LIS names no bill behind a count; get_bill_history is the record of where one bill went.

Inputs: chamber (required), session_code (required). Returns: object

get_communicationA

One communication between the chambers: each statement and the bills it names.

statements are the clerk's sentences in order ("THE SENATE HAS PASSED THE FOLLOWING HOUSE BILLS:"), each with its bills, their chief patrons, and the document_code of the text version acted on. A communication records what a chamber did, not how it voted: it carries no vote ids. LIS holds structured content from May 2024 on. An older communication comes back with no statements and an html link to the original.

Inputs: communication_id (required).

get_current_sessionA

The General Assembly's current working session.

During the interim this is the upcoming session, not the one that just ended; continued bills and new prefiles accumulate there. For retrospective work on a finished session, pass that session's code to the other tools instead of relying on this default.

Inputs: no named parameters. Returns: object

get_floor_calendarA

One floor calendar: the bills up for action, by section, with the votes taken.

calendar_id comes from list_floor_calendars. Each bill carries its calendar section (e.g. "Senate Bills on Third Reading") and the actions recorded against it, with a vote_id where a vote was taken; pass that with the bill number and session code to get_roll_call.

Inputs: calendar_id (required).

get_memberA

One member's roster record: name, chamber, party, district, status, contact.

Reads the session roster, which is the authoritative source (LIS's by-id endpoint answers nothing for some sitting members). Use get_member_committees for seats, get_member_bills for patronage, get_member_votes for the voting record, and get_member_office for the district office.

Inputs: member_id (required), session_code (required). Returns: object

get_member_billsA

Every bill a member patrons in a session, in any role.

The session bill list names only chief patrons, so this is the route to a member's co-patronage. is_chief_patron marks the bills the member sponsors; role restricts the list to one role. query is a case-insensitive substring match against the bill number, description, and title. limit is capped at 200; page with offset.

Inputs: member_id (required), session_code (required), role, limit, +2 more.

get_member_committeesA

Every committee seat one member holds in a session, with the role.

LIS has no member-first committee endpoint, so this reads every seat list in the member's chamber: 14 requests cold for a House member, 67 with subcommittees, all cached afterwards.

Inputs: member_id (required), session_code (required), include_subcommittees. Returns: object

get_member_officeA

A member's district office: postal address, phone, and email.

The district office is the contact detail LIS publishes nowhere else; get_member has the Capitol room, phone, and email. The record is not session scoped, so there is no session code. Many members have no record, and found is false for them.

Inputs: member_id (required). Returns: object

get_member_votesA

Every vote one member cast in a session, or their votes on one bill.

Floor, committee, and subcommittee votes all appear, in LIS order. A row is one (vote, bill) pair: a block vote that disposed of 105 bills appears 105 times, each with is_block true and bills_in_vote set. A block vote is a real vote, but not a considered position on any one bill; exclude_block_votes drops them. total_matching counts rows and distinct_votes counts votes cast. Attendance roll calls are omitted. limit is capped at 200; page with offset.

Inputs: member_id (required), session_code (required), limit, offset, +2 more.

get_minutes_bookA

One minutes book: each action a chamber or committee took that day, in order.

One record per action, with the bill, the section of business it fell under, the action taken, and the tally. A vote_id here belongs to the bill beside it, which a vote_id in get_bill_history does not always do: pass it with the bill number and the session code to get_roll_call. The tally keeps a presiding officer's tiebreak ("18-Y 18-N 0-A, Chair votes Yea"), which the vote record drops. is_block marks one motion that disposed of many bills, and is_voice a vote that names no members. include_procedural adds the entries that name no bill: the call to order, recesses, communications received. A floor day runs to about 200 records; limit is capped at 200, page with offset.

Inputs: minutes_book_id (required), limit, offset, include_procedural.

get_roll_callA

Who voted which way on a bill, with party and district, one entry per vote.

Members are grouped under yea, nay, abstain, and not_voting. statements are corrections members filed ("recorded as yea. Intended to vote nay."); the recorded response still stands. Only votes that record members on this bill alone are included: voice votes and block votes are left out (get_bill_votes lists those too). vote_id narrows the result to one vote.

Inputs: bill_number (required), session_code (required), vote_id.

get_sessionC

One session with its milestone dates: prefiling, convening, adjournment.

events are the dates LIS records for the session, oldest first: "Prefile Date", "Session Start", "Adjournment" (the regular session's sine die), and "Reconvene" (the one day session that takes up the Governor's vetoes and recommendations). projected_date is the planned date LIS holds for an event.

Inputs: session_code (required). Returns: object

get_session_statisticsA

LIS's own bill counts for a session, by chamber of origin and legislation type.

One row per chamber and type (B bill, J joint resolution, R resolution); a type with no bills has no row. total is introduced plus continued_from_last_session, and passed counts chaptered plus vetoed bills. LIS computes these counts itself and they do not always agree with the bill list: a total can miss by a bill, the outcome columns add up differently in each session, passed_house and passed_senate are not a funnel, and continued_to_next_session overcounts (pending matches the next session). Count from list_bills when a number has to be exact.

Inputs: session_code (required). Returns: object

list_amended_billsA

Every bill in a session that carries an amendment, with its amendments.

amended_by picks the chamber that offered the amendments, not the chamber of the bills: "H" returns the bills with a House amendment, Senate bills among them, and only their House amendments. Each amendment has its document_code (HB1005AH1 is the first House amendment to HB1005), a description that names the committee or the floor, and a disposition (Adopted, Not Adopted, Engrossed, Removed, Posted). query is a case-insensitive substring match against the bill number and description. limit is capped at 200; page with offset.

Inputs: session_code (required), limit, query, offset, +1 more.

list_billsA

List bills in a session, optionally filtered by a search term.

query is a case-insensitive substring match against the bill number, description, and title. limit is capped at 200; page through larger result sets with offset. total_matching counts all matches, not just the returned page.

Inputs: session_code (required), limit, query, offset. Returns: object

list_committeesA

The standing committees of one or both chambers, optionally with subcommittees.

The list is not session scoped: it describes the committees that exist now. Who sits on them is session scoped; see get_committee. Use a committee's number ("H08") or name with get_committee, list_meetings, and list_dockets.

Inputs: chamber, include_subcommittees. Returns: object

list_communicationsA

The messages the two chambers sent each other in a session, newest first.

A communication is the formal notice a clerk sends the other chamber: "The House of Delegates has passed the following Senate bills". chamber is the chamber that sent it. The rows name no bills; pass a communication_id to get_communication for those. reference is unique within one session only. limit is capped at 200; page with offset.

Inputs: session_code (required), limit, offset, chamber.

list_conference_billsA

The bills of a session that went to a conference committee.

A conference committee settles the differences when the two chambers pass different versions of a bill. chamber is the bill's chamber of origin, and member_id narrows the list to the conferences one member sat on. The rows name no conferees: get_bill_history lists them on the bill's events ("House Conferees: ..."). limit is capped at 200; page with offset.

Inputs: session_code (required), limit, offset, chamber, +1 more.

list_docketsA

A Senate committee's dockets for a session: each meeting and the bills on it.

Dockets are the Senate's committee agendas, newest first as LIS lists them. The House keeps none in the API: read a House bill's committee from get_bill_history and the committee's meetings from list_meetings. committee is a Senate committee number ("S13") or name. A docket and its linked schedule can disagree on the hour, so both times are reported. Costs one request per docket cold, cached afterwards.

Inputs: committee (required), session_code (required).

list_floor_calendarsA

A chamber's floor calendars for a session, one per sitting.

A floor calendar is the day's order of business: the bills up for a reading or a vote. Pass a calendar_id to get_floor_calendar for the bills on it. Several calendars can share a date.

Inputs: chamber (required), session_code (required). Returns: object

list_meetingsA

Meetings on the master schedule in a date range: committees, floor, caucuses.

Dates are YYYY-MM-DD and inclusive; keep the range short, since a week in session is about 150 meetings. committee narrows the list to one committee by number or name (chamber disambiguates a name found in both chambers). time is free text as the clerk entered it ("15 minutes after adjournment") and may be blank. Cancelled meetings stay listed with cancelled true. limit is capped at 200; page with offset.

Inputs: end_date (required), start_date (required), limit, offset, +3 more.

list_membersA

The session's member roster, searchable by name, chamber, and party.

query matches any part of a name, ignoring case ("schmidt", "Charlie Schmidt", "Schmidt, C"); omit it for the whole roster. The roster deliberately includes members who left or arrived mid-session (service_end_date and service_end_reason mark a departure): they cast the votes recorded before they left. member_id is the key for the member tools.

Inputs: session_code (required), party, query, chamber.

list_minutes_booksA

The published minutes books of a session, newest first.

A minutes book is the clerk's record of what one body did on one day. Both chambers publish committee books. Only the Senate publishes floor books (is_floor true), so read House floor action from list_floor_calendars and get_bill_history. committee is a number or name, and it excludes every floor book; kind picks the floor books or the committee books. Dates are YYYY-MM-DD and inclusive. A book with status "In Progress" can still change. Pass a minutes_book_id to get_minutes_book for the bills and votes. limit is capped at 200; page with offset.

Inputs: session_code (required), kind, limit, offset, +4 more.

list_most_viewed_billsA

The bills of a session that readers of the LIS website open most often.

LIS sends at most 100, in its own order, with the same fields as search_bills. The list measures public attention, not legislative weight.

Inputs: session_code (required), limit.

list_sessionsA

Legislative sessions for a calendar year.

Returns each session's code, e.g. 20261 = 2026 Regular Session and 20262 = 2026 Special Session I. The reference list reaches back to 1994.

Inputs: year (required). Returns: object

list_votesA

Every vote a chamber took in a date range: floor, committee, and subcommittee.

Dates are YYYY-MM-DD and inclusive; end_date defaults to start_date, which gives one day. Keep the range short, since a chamber takes about 50 votes on a session day. chamber is the chamber that voted, so a row can name a bill from the other chamber. Rows carry the tally and no members: pass a row's bill_number and vote_id to get_roll_call for those. A block vote names no bill, most voice votes are missing, and classification "Attendance" marks a quorum call. limit is capped at 200; page with offset.

Inputs: chamber (required), start_date (required), session_code (required), limit, +2 more.

search_billsA

Search a session's bills by keyword, stage, patron, or chapter number.

This is the full text search; list_bills only matches the number and the short description. keyword searches the summaries, or the bill text when search_in is "Bill Text", and takes AND, OR, and parentheses ("firearm AND ammunition"). LIS drops common words, so "the" finds nothing. category is a stage a bill reached, by name: "In Committee", "Passed House", "Continued", "Vetoed", "Acts of Assembly chapters"; an unknown name answers with the full list. member_id narrows to one patron in any role. chapter finds the bill behind an Acts of Assembly chapter (350 finds CHAP0350). At least one of the four is required.

One row per bill, in LIS order, with status, chapter, chief patron, and the committee that holds the bill. include_summaries adds the plain text of each bill's furthest-along summary. A keyword search on its own includes failed bills; with category or member_id LIS leaves out failed and incorporated bills. limit is capped at 200; page with offset.

Inputs: session_code (required), limit, offset, chamber, +6 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 38 tools

    Disambiguation4/5

    The set has several potentially overlapping clusters (list_bills vs search_bills; get_bill_votes vs get_bill_vote_tallies vs list_votes vs get_member_votes vs get_roll_call), but descriptions explicitly draw the boundaries (e.g. tallies is 'lighter and knows less', list_bills only matches number/description while search_bills is full text). A careful agent can select correctly, though the five-tool vote surface requires reading closely. No tool appears to do the same thing as another.

    Naming Consistency5/5

    Everything is snake_case with a predictable verb_noun pattern (get_bill, list_sessions, search_bills, check_api_key), and the get_/list_ split maps cleanly to single-record vs collection. Minor variants like list_most_viewed_bills or get_bill_vote_tallies are still readable and on-pattern. No mixed casing or vague verbs.

    Tool Count3/5

    38 tools is heavy and well above the comfortable 3-15 band, so discovery cost is real, but the domain (sessions, bills, members, committees, meetings, dockets, calendars, minutes, communications, votes) is genuinely broad and most tools map to a distinct resource or operation. It sits at the borderline of justified breadth rather than bloat.

    Completeness5/5

    Coverage spans the full legislative lifecycle: sessions, bills, versions, text, history, votes and roll calls, patrons, members, offices, committees and staff, meetings, dockets, floor calendars, minutes books, and inter-chamber communications, plus aggregate statistics. The read-only surface has no obvious dead ends for the domain, and cross-tool chaining (e.g. vote_id, member_id, committee number) is consistently documented.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables querying U.S. legislative data from Congress.gov API using MCP resources for direct lookups and tools for searching and retrieving related data.
      8
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables querying legislative data from the LegiScan API, including bills and votes, via natural language through an MCP gateway.
      260 npm
      MIT
    • F
      license
      A
      quality
      C
      maintenance
      Exposes a Congress.gov-style legislative GraphQL API to MCP clients, enabling querying bills, actions, committee activities, and cosponsors via natural language.
      7
      -
    • A
      license
      A
      quality
      B
      maintenance
      Remote MCP server for nonpartisan U.S. Congress data: plain-language bill decodes (bilingual EN/ES), representative lookup by ZIP with district-office phones, and what's-moving urgency ranking. Read-only, keyless.
      5
      1
      AGPL 3.0