va-lis-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@va-lis-mcp What's the latest action on HB 1234 from the 2024 session?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
uvxlauncher used below. Install it with one line:curl -LsSf https://astral.sh/uv/install.sh | sh(macOS/Linux) orpowershell -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-mcpClaude 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-mcpThe 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 |
| none | The GA's working session, with a note on what "current" means during the interim |
|
| Sessions for a calendar year with their codes (reference data reaches back to 1994) |
|
| One session with its milestone dates: prefiling, convening, adjournment, and the reconvened session |
|
| Bill rows filtered by a substring match on number, description, and title; paginated, with a total match count |
|
| 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 |
|
| The bills readers of the LIS website open most often, at most 100 |
|
| Every bill that carries an amendment, with each amendment's document code, chamber, and disposition; paginated |
|
| The bills that went to a conference committee, for the session or for one conferee; paginated |
|
| Full bill detail: title, status, dates, patrons grouped by role, and the session lineage list |
|
| Every patron with member id, role, and chamber, in LIS display order |
|
| Plain text summaries (as introduced, as passed); the active entry is the current one |
|
| Plain text of one version (default: most recent), truncated at 15,000 characters, plus the list of available versions |
|
| Every published version with its chamber, sponsor, and disposition, and the links to its PDF, HTML, and fiscal impact statements |
|
| Chronological events with date, description, actor, committee, vote tally, |
Votes
Tool | Inputs | Returns |
|
| Every vote the bill saw in either chamber (floor, committee, subcommittee) with tally, outcome, and the voice, block, and roll call flags |
|
| The same votes in two requests: tallies and no members, with most voice votes missing |
|
| Every vote one chamber took in a date range, with the bill and the tally; paginated |
|
| 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 |
|
| One member's votes across a session or on one bill, with block votes flagged; paginated |
Members
Tool | Inputs | Returns |
|
| The session roster, searchable by any part of a name, departed members included |
|
| One roster record with party, district, status, and contact details |
|
| The member's district office: postal address, phone, and email, when LIS holds one |
|
| Every bill the member patrons, with chief patronage flagged; paginated |
|
| The member's committee seats and roles |
Committees
Tool | Inputs | Returns |
|
| The standing committees, with subcommittees on request |
|
| The committee's roster for the session with each member's role, party, and district, its regular meeting note, and its subcommittees |
|
| The clerks and staff who serve the committee, with the date each assignment began |
Meetings
Tool | Inputs | Returns |
|
| The master schedule for a date range: date, the clerk's time text, room, owner, and cancellation flag; paginated |
|
| A Senate committee's dockets with the bills on each (the House keeps none) |
|
| A chamber's floor calendars for the session |
|
| The bills on one floor calendar by section, with the actions and vote ids recorded against each |
Chamber records
Tool | Inputs | Returns |
|
| The published minutes books of a session, newest first, with floor books marked; paginated |
|
| Each action a chamber or committee took that day, with the bill, the tally, and a |
|
| The messages the two chambers sent each other, newest first; paginated |
|
| One communication: each statement of the clerk and the bills it names |
Statistics
Tool | Inputs | Returns |
|
| LIS's own bill counts by chamber of origin and legislation type: introduced, passed, failed, continued, and more |
|
| LIS's own referral counts for each standing committee, split by the bill's chamber of origin |
Diagnostics
Tool | Inputs | Returns |
| 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:
20261is the 2026 Regular Session,20262is 2026 Special Session I. Most tools require one.Bill numbers are unpadded. LIS returns nothing for
HB0001; the correct form isHB1. The tools normalize input (hb0001becomesHB1), 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
LegislationIDin both sessions, so a bill is identified by session code plus bill number. Thesessionslist onget_billis 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_historyflags 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_voteswalks the bill's events and fetches the vote behind each one.get_bill_historycarries thevote_idon 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_callleaves both out,get_bill_votesflags them, andget_member_votesmarks each row withis_block.Not voting is not in the tally. Members recorded as
not_voting(LIS codeX) 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_memberskeeps 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_committeereads the seat list for the session you name. LIS has no "bills referred to a committee" endpoint;get_bill_historynames the committee that holds a bill.Dockets are Senate only. House committee agendas are not in the API:
list_meetingsgives 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_billsmatches the number and the short description of every bill in a session.search_billsis 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_idon a bill's history can point at a vote that disposed of some other bill. Avote_idinget_minutes_bookbelongs 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_calendarsandget_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_talliesandlist_votescost 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_voteshas 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_billswhen a number has to be exact.Staff and offices are not session scoped.
get_committee_staffnames who serves a committee now.get_member_officereads 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 4The 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-mcpUpgrading
uvx caches resolved environments, so after a new release force resolution
of the latest version:
uvx va-lis-mcp@latestLicense
MIT
Available Tools
38 toolscheck_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
Scored across 38 tools
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.
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.
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.
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
Related MCP Connectors
Unofficial LegiScan MCP — wraps the LegiScan API (api.legiscan.com)
Access U.S. congressional data (bills, votes, members, committees) via MCP.
Virginia Open Data (datahub.va.gov) Socrata MCP.
Bills, hearings, votes and legislators for all 50 US states, DC and Congress, from official sources.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables querying U.S. legislative data from Congress.gov API using MCP resources for direct lookups and tools for searching and retrieving related data.8MIT
- AlicenseNot gradedqualityCmaintenanceEnables querying legislative data from the LegiScan API, including bills and votes, via natural language through an MCP gateway.260 npmMIT
- FlicenseAqualityCmaintenanceExposes a Congress.gov-style legislative GraphQL API to MCP clients, enabling querying bills, actions, committee activities, and cosponsors via natural language.7-
- AlicenseAqualityBmaintenanceRemote 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.51AGPL 3.0