ConvoKit: a scikit-learn-style toolkit for conversation analysis and social phenomena
ConvoKit is a toolkit for extracting conversational features and analyzing social phenomena in conversations. It includes several large conversational datasets along with scripts exemplifying the use of the toolkit on these datasets.
At a glance
- What is it?
- ConvoKit bundles conversational datasets with feature extractors for coordination, politeness, hypergraph structure and outcome forecasting. It is a research toolkit for computational social science, and its value depends on whether your questions match the phenomena it already implements.
- Who is it for?
- Adopt ConvoKit if your research question is one of the phenomena it already implements (coordination, politeness, hypergraph structure, expected context, diversity, forecasting) and you want the bundled datasets to compare against published results. Do not adopt it as a general-purpose dialogue framework or as a preprocessing layer for an LLM pipeline; it is not built for that.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 77 days ago.
- What is it written in?
- Mainly Jupyter Notebook, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The problem ConvoKit solves: conversations as structured objects, not raw text
Most NLP tooling treats input as a flat sequence of tokens. Conversation data is not flat. It has speakers, reply relationships, temporal ordering, and group structure that changes as the exchange develops. ConvoKit's premise is that these should be first-class objects in the API rather than something you reconstruct with pandas joins before every experiment.
The README describes the toolkit as extracting conversational features and analyzing social phenomena in conversations, using a single unified interface inspired by and compatible with scikit-learn. That compatibility claim is the design centre. If you have used scikit-learn, the shape of the API should be familiar: objects that you configure, then call fit or transform on conversation data.
The intended audience is computational social scientists and NLP researchers who study interaction rather than single documents. The examples in the repository point at U.S. Supreme Court oral arguments, Wikipedia talk pages, Reddit, ChangeMyView, British parliamentary question periods, and the Switchboard dialog acts corpus. That list is a fair description of the research community the project is aimed at: people who publish papers about power, politeness, derailment and linguistic development in real exchanges.
What ships in the box: datasets plus the feature extractors that consume them
ConvoKit is unusual in bundling large conversational datasets alongside the code. The README states that several large conversational datasets are included together with scripts exemplifying the use of the toolkit on these datasets. This matters for reproducibility. Published results in this area are often hard to re-derive because the corpus is behind an access form or the preprocessing was never released. Here the demo notebooks reference the same corpora the toolkit ships.
On the feature side, the README lists these implemented areas: linguistic coordination, measured through function word use as a proxy for influence and relative power between individuals or groups; politeness strategies, described as lexical and parse-based features correlating with politeness and impoliteness; the Expected Conversational Context Framework, which characterizes utterances and terms by their expected conversational context and includes model implementations and wrapper pipelines; hypergraph conversation representation, which extracts structural features through a hypergraph; linguistic diversity, computing diversity of individuals within their own conversations and between individuals in a population; CRAFT, a neural model for forecasting future outcomes of conversations such as derailment into personal attacks; and redirection and utterance likelihood methods.
One detail worth reading carefully: the prompt types section in the README is commented out, and the phrasing motifs API is mentioned inside that same commented block. So a feature you may have seen in an older paper or an older version of the docs might not be part of the current documented surface. Check the live documentation before assuming it is available in 4.1.2.
Getting it running: pip, Python 3.10, and the notebook path
The installation surface is deliberately small. ConvoKit is distributed on PyPI, and the README's badge line pins the supported interpreter at Python 3.10 or later. The package name is convokit, so the install is a standard pip install. The README does not spell out the exact command in the text provided, but the PyPI badge and the package name make it unambiguous.
The faster route to a working environment is the interactive tutorial. The README links a Colab notebook at examples/Introduction_to_ConvoKit.ipynb, described as an interactive tutorial. If you want to evaluate the API before installing anything locally, that notebook is the shortest path, and it is also the honest way to find out whether the object model matches how you think about your own data.
The rest of the examples live in the repository under examples/, organised by feature area rather than by dataset. Coordination has examples/coordination/examples.ipynb. Politeness and derailment share examples/conversations-gone-awry/Conversations_Gone_Awry_Prediction.ipynb. Hypergraph work is in examples/hyperconvo/hyperconvo_demo.ipynb. Speaker diversity is in examples/speaker-convo-attributes/speaker-convo-diversity-demo.ipynb. The expected context framework keeps its demos inside the package itself, at convokit/expected_context_framework/demos/, with separate notebooks for parliament, Switchboard, Wikipedia and SCOTUS.
CRAFT is the exception to the notebook-in-repo pattern. It is offered as two Colab notebooks, one for fine-tuning plus inference and one for inference only. That split is a useful signal: the fine-tuning path expects more compute than the inference path, and the project has chosen not to pretend otherwise.
The unified interface is the real product, and it constrains what you can do
The scikit-learn compatibility claim is doing more work than it first appears. A shared interface across coordination, politeness, hypergraph features and forecasting means you can swap one feature extractor for another inside the same pipeline without rewriting your data loading. For a research group running several studies over the same corpora, that is the difference between one codebase and five.
The cost is that every feature has to be expressible in that interface. Methods that do not fit the fit/transform shape, or that need custom training loops, end up as separate notebooks rather than as pipeline components. CRAFT is the clearest example: it is a neural model with fine-tuning, and it is delivered as Colab notebooks rather than as something you would drop into a scikit-learn Pipeline. That is a reasonable boundary, but it means the unified interface covers the classical feature extractors more completely than it covers the neural ones.
A second consequence is version coupling. With three releases in roughly four months (4.1.0 in March 2026, 4.1.1 in May, 4.1.2 in June), the interface is still moving. If you pin an older version for a paper, expect to re-verify feature outputs when you upgrade, because a shared interface makes it easy to change behaviour in one place and affect every downstream study.
Where ConvoKit is the wrong tool
ConvoKit is not a dialogue system framework. There is no agent loop, no response generation, no serving layer. If you are building a chatbot, the toolkit will not help you, and the fact that it appears in searches for conversational AI will waste your time.
It is also not a general preprocessing library. The feature extractors are opinionated: coordination is defined through function words, politeness through a specific set of lexical and parse-based cues. If your research question needs a different operationalisation of the same concept, you are better off implementing it directly than bending the existing extractor. The published definitions behind these features are linked from the README, and they are the right thing to read before deciding whether the built-in measure matches your construct.
The dataset bundling is a double-edged property. Large corpora mean large downloads and non-trivial disk usage, and the README does not state per-dataset sizes in the material available here. If you only need the feature extractors and already have your own conversation data, you are still pulling a package whose distribution includes dataset tooling. Whether that is a problem depends on your environment, and it is worth checking the installed size before adding ConvoKit to a constrained container image.
Finally, the Python 3.10 or later requirement will exclude older research environments. If your lab cluster is pinned to 3.8 or 3.9, you are choosing between upgrading the environment and not using the toolkit.
How it compares to building on a general conversation corpus library
The closest alternative in spirit is a general-purpose dialogue corpus loader such as the datasets library from Hugging Face. The difference in approach is what each one considers the unit of work. A corpus loader gives you a dataset and stops; you write the feature extraction yourself, which means you can implement anything, but you also reimplement the same coordination and politeness measures that ConvoKit already ships and that reviewers already recognise.
ConvoKit makes the opposite bet. It assumes the interesting part is the phenomenon, not the plumbing, and it ships the measures. The trade is that you inherit someone else's definitions. For a paper that needs to be comparable to prior work using these same measures, inheriting them is the point. For a paper that needs a novel measure, the corpus loader is the lighter dependency.
A second comparison is against pulling individual research codebases. Several of the papers behind ConvoKit's features have their own released code. Using those directly gives you the original implementation, but each comes with its own data format and its own dependencies. ConvoKit's contribution is putting them behind one interface and one data model, so the cost of using three measures is closer to the cost of using one. Whether that consolidation is worth it depends on how many of the measures you actually need. If you need exactly one, the original codebase may be simpler.
Maintenance, licence and what to verify before you depend on it
The project is not archived, and the release cadence shown here is active: 4.1.0 in March 2026, 4.1.1 in May 2026, 4.1.2 in June 2026. The README also points to a Discord community for progress updates and issue discussion. For a research toolkit, that combination of recent releases and an open channel is the practical signal that matters, more than any single metric.
Upgrade cost is the thing to plan for. Patch releases in a toolkit with a unified interface can change feature outputs, and if you have published numbers from an earlier version you will want to record which version produced them. The README names the current version explicitly in the text, which is helpful, but it does not include a changelog in the material available here, so the release notes on GitHub are where you would check what changed between 4.1.0 and 4.1.2.
The licence is MIT, stated in the README badge and the LICENSE.md file. MIT is permissive, which generally means you can use, modify and redistribute the code with the copyright notice preserved. That is a summary of the licence's usual terms, not legal advice, and it says nothing about the datasets. Dataset licensing is separate from code licensing and is frequently more restrictive. The README does not state per-dataset terms in the material available here, so if you plan to redistribute a corpus or use it commercially, check the dataset's own terms before assuming the MIT licence covers it.
Before adopting, verify three things: that the datasets you need actually download in your environment, that your interpreter is 3.10 or later, and that the feature you want is in the current documented API rather than in the commented-out section of the README. Those three checks take an afternoon and prevent the most common way this kind of dependency goes wrong.
Editorial conclusion
Adopt ConvoKit if your research question is one of the phenomena it already implements (coordination, politeness, hypergraph structure, expected context, diversity, forecasting) and you want the bundled datasets to compare against published results. Do not adopt it as a general-purpose dialogue framework or as a preprocessing layer for an LLM pipeline; it is not built for that. Before committing, verify in the documentation which datasets actually download in your environment, check that the Python version is 3.10 or later, and confirm that the specific feature extractor you need is not still commented out in the README.
Community notes