Contribute to LangChain Open Source

Make a real pull request to LangChain, a 135K-star AI repository.

Introduction

30 Second Summary

Every developer eventually reads open source code. The ones who stand out are the ones who contribute back. A single merged pull request proves you can navigate real codebases, collaborate with strangers, and ship production-quality work.

In this project, you will make a real contribution to LangChain, one of the most popular open source AI repositories on GitHub (135K+ stars). You will fork the repo, find a beginner-friendly issue, write a focused fix, and submit a professional pull request.

What You'll Build

You will submit a real pull request to the LangChain repository following the project's contribution conventions.

By the end of this project, you'll have:

  • A forked copy of the LangChain repository configured with upstream tracking.
  • A local development environment with Poetry, passing linting and tests.
  • A submitted pull request with a structured description linking your claimed issue.
  • Secret Mission: Navigate your first code review by responding to maintainer feedback and getting your PR merged.

Are there any prerequisites?

You should have basic Python proficiency, basic Git knowledge (clone, commit, push), and an existing GitHub account. No prior open source experience is required.

Set Up and Verify Your Tools

Before you can contribute to LangChain, you need to make sure your development tools are properly configured.

In this step, you will verify that Git and Python are set up correctly, install Poetry (the dependency manager LangChain uses), and confirm your machine can talk to GitHub over HTTPS.

In this step, get ready to:
  • Verify Git is installed and configured with your identity.
  • Confirm Python 3.9 or higher is available.
  • Install Poetry and verify it works.
Verify Git and Python are ready

Your commits need to be tied to your GitHub identity. If your Git name and email do not match your GitHub profile, maintainers may not associate your contribution with you.

  • Open your terminal. Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Terminal (macOS) or PowerShell (Windows) and press Enter to open it.
  • Confirm Git is installed by running:
git --version

You should see a version number like git version 2.x.x.

  • Check that Git knows your name and email by running these commands:
git config --global user.name
git config --global user.email

You should see your name and email printed back. These must match the name and email on your GitHub profile.

Why do these need to match my GitHub profile?

When you push commits, GitHub uses the email address in your commit metadata to link the commit to your account. If the email does not match, your commits will appear as from an unknown user, and maintainers cannot verify your identity.

✔️ I see my name and email

You are all set. Move on to the Python check below.

ⓧ I see nothing or the wrong values

  • Set your Git username by running:
git config --global user.name "Your Name"
  • Set your Git email by running:
git config --global user.email "your-email@example.com"

Replace the values with the exact name and email from your GitHub profile.

  • Open github.com in your browser.
  • Click your profile picture in the top-right corner, then select Settings.
  • Select Public profile to find your display name and email.
  • Confirm your Python version by running:
python --version

Python command varies by system

On some systems the command is python3 instead of python. If python --version shows an error or a version below 3.9, try python3 --version instead.

✔️ I see Python 3.9 or higher

Your Python version is ready. Move on to installing Poetry below.

ⓧ I see a version lower than 3.9

You need Python 3.9 or higher for LangChain development.

  • Download the latest Python from python.org/downloads.
  • Run the installer and follow the prompts.
  • Close and reopen your terminal, then run python --version again to confirm.

Still seeing the old version?

On macOS, the system Python may shadow your new install. Try running python3.11 --version or python3.12 --version to check if the newer version is available under a different name.

Help me fix my Python PATH

ⓧ Command not found

Python is not installed on your system.

  • Download Python from python.org/downloads.
  • Run the installer. On Windows, check the box that says Add Python to PATH before clicking Install Now.
  • Close and reopen your terminal, then run python --version again.
Install Poetry

LangChain uses Poetry to manage its Python dependencies. Poetry handles virtual environments and package resolution across the monorepo's many sub-packages.

What is Poetry?

Poetry is a dependency manager for Python projects. It reads a pyproject.toml file to know which packages a project needs, then installs them into an isolated virtual environment so they do not conflict with your system packages.

  • Install Poetry by running the official installer command for your operating system:

macOS

curl -sSL https://install.python-poetry.org | python3 -

The installer will download and set up Poetry. At the end, it may print a message telling you to add ~/.local/bin to your PATH.

  • If you see that PATH message, add the directory to your shell configuration by running:
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

If your shell is Bash instead of Zsh, replace ~/.zshrc with ~/.bashrc.

Windows

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -

The installer will download and set up Poetry. It places the poetry executable in %APPDATA%\Python\Scripts.

  • If the verification step below fails, you may need to add that directory to your PATH. Close and reopen PowerShell after the install finishes.
  • Verify Poetry is working by running:
poetry --version

✔️ I see a version number

Poetry is installed and on your PATH. You are ready to move on.

ⓧ Command not found

The poetry binary is not on your PATH yet.

  • On macOS/Linux, confirm that ~/.local/bin is in your PATH by running echo $PATH. If it is missing, add it using the command in the macOS tab above, then restart your terminal.
  • On Windows, close and reopen PowerShell. If it still fails, manually add %APPDATA%\Python\Scripts to your system PATH.
  • To edit your system PATH on Windows:
  • Open Settings.
  • Select System, then About.
  • Click Advanced system settings.
  • Click Environment Variables and add the path to your Path variable.

Still not working?

Make sure you are opening a new terminal window after modifying PATH. Changes to shell configuration files only apply to new sessions.

Help me add Poetry to my PATH

Confirm GitHub HTTPS access

You will clone and push to GitHub over HTTPS throughout this project. A quick check now prevents authentication headaches later.

  • Test your connection to the LangChain repository by running:
git ls-remote https://github.com/langchain-ai/langchain.git

You should see a list of branch and tag references printed in your terminal. This confirms your machine can reach GitHub over HTTPS.

Seeing a connection error?

Make sure you are connected to the internet. If you are behind a corporate firewall or VPN, HTTPS access to github.com may be blocked. Try switching to a personal network to test.

Help me troubleshoot my GitHub connection

Your development environment is ready. Next up, you will scout the LangChain project to understand its structure and conventions before writing any code.

Scout the LangChain Project

Your development environment is locked and loaded. Git, Python, and Poetry are all confirmed working.

Before you write a single line of code, you need to understand how LangChain expects contributions to arrive. Most first-time contributors skip this step and submit PRs that get ignored or closed. Reading the project's documentation, studying successful PRs, and understanding the codebase structure is what separates contributors who get merged from those who don't.

In this step, get ready to:
  • Read the contribution guidelines and identify key requirements.
  • Study recently merged pull requests to learn the team's conventions.
  • Map the monorepo structure so you know where your changes belong.
Read LangChain's contribution guidelines

Every serious open source project has a CONTRIBUTING.md file that spells out how to submit changes. This is your contract with the maintainers. If you break it, your PR gets closed without review.

What should I look for?

As you read, note these key requirements that will affect every step of your contribution:

  • The project uses a fork-and-PR workflow. You never push directly to the main repository.
  • All PRs must pass formatting, linting, and testing checks before they can be merged.
  • Tests live in two directories: tests/unit_tests and tests/integration_tests.
  • Documentation is built with Docusaurus.
  • Issues labelled good first issue and help wanted are designed for new contributors.
Review recently merged pull requests

Reading merged PRs is like studying successful exam answers before taking the test. You learn the tone, scope, and format that maintainers reward.

What patterns should I notice?

Successful LangChain PRs share consistent patterns. Look for these as you browse:

  • PRs are small and focused. Each one tackles a single issue or improvement.
  • Descriptions link the related issue with keywords like "Closes #12345" or "Fixes #12345".
  • CI checks are green before review. Maintainers don't review failing PRs.
  • Commit messages follow a conventional format like fix: description (#XXXXX) or docs: description.

Look at reviewer feedback too

Pay attention to how reviewers phrase their requests. This tells you what maintainers care about most. Common feedback themes include missing tests, overly broad changes, and formatting issues.

Map the monorepo structure

LangChain is a monorepo containing multiple packages in a single repository. If you make changes in the wrong sub-package, your PR will be rejected regardless of code quality.

  • Navigate to the repository root in your browser: https://github.com/langchain-ai/langchain
  • Click on the libs/ directory to see the sub-packages.
  • Open 2 to 3 sub-packages and notice that each one has its own pyproject.toml, tests/ folder, and documentation.

What are the key sub-packages?

The libs/ directory contains the main packages you might contribute to:

  • libs/langchain is the main LangChain package with chains, agents, and retrieval logic.
  • libs/core contains the foundational abstractions that all other packages depend on.
  • libs/community holds community-contributed integrations with third-party tools.

When you claim an issue in the next step, you will need to identify which sub-package it belongs to. This determines where you run poetry install and where you run tests.

Why does the sub-package matter?

Each sub-package has its own pyproject.toml that defines its dependencies and test configuration. Running poetry install --with test from the wrong directory installs the wrong dependencies. Running tests from the wrong directory tests the wrong code.

Always cd into the specific sub-package directory before running any Poetry or test commands.

You now have a mental map of LangChain's expectations and structure. Next up, you will find a real issue to solve and claim it publicly.

Find and Claim Your Issue

You now understand how LangChain's contribution workflow operates, what successful PRs look like, and how the monorepo is organized.

In this step, you will search for a real beginner-friendly issue, evaluate whether it is worth your time, and publicly claim it so no one else picks it up while you work. The difference between contributors who get merged and those who get ignored often comes down to issue selection.

In this step, get ready to:
  • Search for an unassigned good first issue on the LangChain repository.
  • Evaluate candidates and select one that fits your skill level.
  • Claim the issue publicly and write a short plan for your fix.
Search for beginner-friendly issues

Not every open issue is a good pick for your first contribution. You want an issue that has a clear problem statement, points to specific files, and has recent maintainer activity confirming it is still relevant.

repo:langchain-ai/langchain is:issue is:open label:"good first issue" no:assignee
  • Press Enter to run the search.
  • Browse the results and open 3-5 issues that look promising.

What does this search query do?

Each filter in the query narrows the results to issues you can actually work on.

  • is:issue excludes pull requests from the results.
  • is:open shows only unsolved issues.
  • label:"good first issue" filters to issues maintainers have marked as beginner-friendly.
  • no:assignee removes issues someone else has already claimed.

Now evaluate each candidate against these five criteria before picking one.

  • Clear problem statement - the issue describes exactly what is wrong or what needs to change.
  • Acceptance criteria or reproduction steps - you can tell when the issue is solved.
  • Links to relevant code or files - the issue points you to a specific location in the codebase.
  • Low blast radius - the fix is localized to one file or a small set of files, not a sweeping refactor.
  • Recent maintainer activity - a maintainer has commented or triaged the issue within the last few months.

Skip issues that fail two or more criteria

An issue with a vague description and no linked files will take significantly longer than one with clear pointers. You want your first PR to be a smooth experience, not a treasure hunt.

  • Pick one issue that passes all five criteria (or at least four out of five).
  • Write down the issue number (e.g., #12345) and note which sub-package it belongs to (e.g., libs/langchain or libs/core).

Why does the sub-package matter?

The LangChain monorepo has multiple packages under libs/. Each one has its own pyproject.toml, tests, and dependencies.

Knowing which sub-package your issue lives in tells you exactly where to cd into when you set up your development environment in the next step.

Claim your issue publicly

Claiming an issue signals to maintainers and other contributors that someone is actively working on it. Without a claim comment, another person might start the same fix in parallel.

  • Scroll to the comment box at the bottom of your chosen issue.
  • Write a short claim comment. Something like this works well:
Hi, I'd like to work on this. I've read the CONTRIBUTING.md and understand the expected change. Is this still available?

What makes a good claim comment?

Mentioning that you have read the contribution guidelines tells the maintainer you are prepared. Asking if the issue is still available is polite and accounts for the fact that someone else may have started without commenting.

If no one has claimed the issue in 2+ weeks, you can proceed immediately without waiting for a reply.

  • Click Comment to post your claim.

All the good first issues are already assigned?

Remove the no:assignee filter and look for issues where the assignee has not commented in 2+ weeks. You can politely ask: "Hi, are you still working on this? I'd like to pick it up if not."

help me find available issues to contribute to on the LangChain repository

Plan your approach before writing code

Professional contributors think through their fix before touching any code. A quick plan keeps your PR focused and prevents scope creep.

  • Open a text file or notes app and answer these three questions about your chosen issue:
  • Which file(s) will I change? Look at the issue description and any linked code. Name the specific file paths (e.g., libs/core/langchain_core/utils.py).
  • What does the fix or improvement look like? Describe the change in 1-2 sentences. For example: "Add a missing parameter validation in the constructor" or "Update the docstring to include the Returns section."
  • How will I verify it works? Name the test you will add or run. For example: "Add a unit test in tests/unit_tests/test_utils.py that checks the new validation raises a ValueError."

Why plan before coding?

A plan helps you resist the temptation to fix unrelated things while you are in the code. Successful PRs in the LangChain repo are small and focused. One PR, one idea.

Your plan also gives you a checklist to measure your PR against before submitting.

Not sure which files to change?

Use GitHub's search within the repository. Click the code search bar at the top of the repo page, type a relevant function name or error message from the issue, and see which files come up.

help me identify the right files to change for my LangChain issue

You now have a claimed issue, a clear target, and a plan of attack. Next up, you will fork the repository, clone it locally, and get your development environment running so you can start implementing your fix.

Fork, Clone, and Set Up the Dev Environment

You've scouted the project, found a beginner-friendly issue, and claimed it with a comment. Now it's time to get your own working copy of the codebase so you can actually write and test code.

In this step, you'll fork the LangChain repository to your GitHub account, clone it locally, and install the development dependencies using Poetry. By the end, you'll have a fully working environment where tests and linting pass cleanly.

In this step, get ready to:
  • Fork and clone the LangChain repository with upstream tracking.
  • Install development dependencies using Poetry.
  • Run the formatter and linter to establish a clean baseline.
Fork and clone the repository

A fork is your personal copy of the LangChain repository on GitHub. You push your changes to the fork, then open a pull request from there to the original project.

  • Open the LangChain repository in your browser:
  • https://github.com/langchain-ai/langchain
  • In the top-right corner of the page, click Fork.
  • Under Owner, select the dropdown menu and click your GitHub username.
  • Select Copy the DEFAULT branch only. This keeps your fork lightweight for contribution purposes.
  • Click Create fork.

What is a fork?

A fork is a full copy of a repository that lives under your GitHub account. You have full write access to your fork, which means you can push branches to it freely.

When your code is ready, you'll open a pull request from your fork back to the original repository. The maintainers review your PR without giving you write access to their repo.

Now clone your fork to your local machine and configure it to track the original repository.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Clone your fork locally by running this command:
git clone https://github.com/[[YOUR_USERNAME="your GitHub username"]]/langchain.git

Why does this take a while?

The LangChain repository is large (135K+ stars, thousands of files). The initial clone downloads the full history, so it may take a few minutes depending on your internet speed.

  • Move into the cloned repository by running:
cd langchain
  • Add the original LangChain repository as an upstream remote by running:
git remote add upstream https://github.com/langchain-ai/langchain.git
  • Verify both remotes are configured correctly by running:
git remote -v
  • You should see four lines: origin pointing to your fork (fetch and push) and upstream pointing to langchain-ai/langchain (fetch and push).

Why add an upstream remote?

The upstream remote lets you pull the latest changes from the original LangChain repository. Before starting work, you'll always fetch from upstream to make sure your branch is based on the latest code.

Not seeing both remotes?

Make sure you ran the git remote add upstream command from inside the langchain directory. If you see only origin, run the git remote add upstream command again.

help me fix my git remotes for LangChain

Install development dependencies

LangChain is a monorepo with multiple packages under the libs/ directory. Each sub-package has its own pyproject.toml and test suite. You need to navigate into the correct sub-package before installing dependencies.

  • Navigate into the sub-package that your issue belongs to by running:
cd [[SUB_PACKAGE="the sub-package for your issue, e.g. libs/langchain or libs/core"]]

How do I know which sub-package?

Your contribution plan from Step 3 already identifies the file(s) to change. Look at the file path. If it starts with libs/core/, navigate to libs/core. If it starts with libs/langchain/, navigate to libs/langchain. The same logic applies to libs/community or any partner package.

  • Install the development dependencies by running:
poetry install --with test

What does this command do?

The --with test flag tells Poetry to install the main dependencies plus the test dependency group. This gives you everything needed to run the project's test suite locally.

Poetry creates an isolated virtual environment automatically, so these packages won't conflict with anything else on your system.

This may take a few minutes as Poetry resolves and installs all dependencies.

  • Confirm your environment works by running the unit tests:

macOS

make test

Windows

poetry run pytest tests/unit_tests
  • You should see test output with passing tests. Some tests may be skipped (this is normal for tests that require API keys or integration services).

Tests failing immediately?

Check that you are inside the correct sub-package directory (e.g. libs/langchain or libs/core), not the top-level langchain directory. Each sub-package has its own pyproject.toml and Poetry must be run from that level.

If you see import errors, try running poetry install --with test again to make sure all dependencies resolved correctly.

help me fix failing tests in my LangChain dev environment

Run the formatter and linter to establish your baseline

Before making any code changes, run the formatter and linter to confirm they pass on the existing code. This establishes a clean baseline so you know any future failures are caused by your changes, not pre-existing issues.

  • Run the formatting and linting checks:

macOS

make format

Windows

poetry run ruff format .
poetry run ruff check .

What does this do?

LangChain uses Ruff for both formatting and linting. The format step auto-fixes code style issues (indentation, trailing whitespace). The check step reports code quality issues (unused imports, undefined variables).

Running both now confirms your environment is set up correctly and gives you a clean starting point.

  • If both commands pass cleanly, your development environment is fully ready.

Seeing linting errors you did not cause?

Occasionally the upstream code may have a recently introduced linting issue. If make format or ruff check reports errors on files you haven't touched, don't worry. Focus only on files relevant to your issue. Pre-existing lint failures are not your responsibility to fix.

help me understand these linting errors in my LangChain setup

Your development environment is ready to go. Next up, you'll create a feature branch, make your code change, and submit your pull request to LangChain.

Make Your Change and Submit Your Pull Request

You have a working dev environment, a claimed issue, and a plan for what to change. Now it is time to make the actual contribution.

In this step, you will create a dedicated branch, implement your focused fix, verify everything passes, and submit a professional pull request to the LangChain repository. The quality of your PR description and your attention to detail are what separate contributions that get merged from those that get ignored.

In this step, get ready to:
  • Create a feature branch from the latest upstream code and implement your change.
  • Run tests and formatting to verify your code passes all checks.
  • Submit a pull request with a structured, professional description.
Create a feature branch and commit your change

Every contribution lives on its own branch. This keeps your work isolated from the main codebase and makes it easy for maintainers to review a single, focused change.

  • Fetch the latest code from upstream and create your feature branch by running these commands:
git fetch upstream
git checkout -b [[BRANCH_NAME="your branch name, e.g. fix/issue-12345-improve-error-msg"]] upstream/main

What do these commands do?

  • git fetch upstream downloads the latest commits from the original LangChain repository without changing your local files.
  • git checkout -b creates a new branch starting from the tip of upstream/main. This ensures your branch is based on the most recent code, not your fork's potentially stale main.

Name your branch descriptively following the project's pattern. Examples: fix/issue-12345-description or docs/improve-xyz.

Now implement your code change. Refer back to the plan you wrote in Step 3.

  • Open the file(s) you identified in your contribution plan.
  • Make your fix or improvement. Keep it focused to one logical change.
  • Do not refactor surrounding code or fix unrelated formatting.
  • If your issue requires a new test, add it in the appropriate tests/unit_tests directory.

Why keep it focused?

Maintainers review hundreds of PRs. A small, single-purpose change is easy to verify and merge quickly. A PR that mixes a bug fix with unrelated formatting changes forces reviewers to untangle your intent and often gets rejected.

Aim for 50-200 lines of diff. Avoid 500+ line changes unless the issue explicitly requires it.

Once your change is ready, verify it passes the project's checks before committing.

  • Run the tests to confirm nothing is broken:

macOS

make test

Windows

poetry run pytest tests/unit_tests
  • Run the formatter and linter to ensure your code matches LangChain's style:

macOS

make format

Windows

poetry run ruff format .
poetry run ruff check .

Tests failing after your change?

  • Read the test output carefully. If a test you did not touch is failing, your change may have introduced a side effect.
  • Make sure you are in the correct sub-package directory (e.g., libs/langchain or libs/core).
  • If the linter flags lines you did not change, you may be running from the wrong directory.

Help me debug failing tests in the LangChain repository

Once tests and formatting pass, stage and commit your change.

  • Stage and commit your files with a conventional commit message by running:
git add .
git commit -m "[[COMMIT_MESSAGE="your commit message, e.g. fix: improve error handling for empty inputs (#12345)"]]"

What is a conventional commit message?

LangChain follows a pattern for commit messages. Start with a type prefix like fix:, docs:, or feat: followed by a short description and the issue number in parentheses.

Example: fix: describe the bug (#XXXXX). This format helps maintainers generate changelogs and understand the scope of each commit at a glance.

Push your branch and open the pull request

Your change is committed locally. Now you need to push it to your fork on GitHub and open a pull request against the upstream LangChain repository.

  • Push your feature branch to your fork by running:
git push origin [[BRANCH_NAME="your branch name, e.g. fix/issue-12345-improve-error-msg"]]

You should see output confirming the branch was pushed to your fork on GitHub.

Push rejected or permission denied?

  • Run git remote -v and confirm origin points to your fork (YOUR-USERNAME/langchain), not the upstream repository.
  • If you see a non-fast-forward error, someone else may have pushed to the same branch name on your fork. Use a different branch name or delete the remote branch first.

Help me fix a git push error to my fork

Now open the pull request on GitHub.

  • Open your fork in your browser at https://github.com/YOUR-USERNAME/langchain.
  • You should see a yellow banner saying Compare & pull request for your recently pushed branch. Click it.
  • If you do not see the banner, click the Pull requests tab and then click New pull request.
  • Confirm the base repository is langchain-ai/langchain and the base branch is main.
  • Confirm the head repository is your fork and the compare branch is your feature branch.

Now write a structured PR description. Use this template:

  • What: One-sentence summary of the change.
  • Why: Link the issue with Closes #XXXXX. Explain the problem being solved.
  • How to verify: Exact test command or steps a reviewer can follow to confirm the fix.
  • Out of scope: What you intentionally did not change.

Why include Out of scope?

Reviewers often ask "why didn't you also fix X?" The Out of scope section pre-empts this by showing you considered related changes and chose not to include them. This signals you understand the principle of small, focused PRs.

  • Click Create Pull Request to submit.
  • Watch the Checks tab on your PR. CI/CD will run the same tests and linting you ran locally.

If CI fails after you already passed locally

This usually means the CI environment tests a broader scope than your local make test run. Read the failing check's log, fix locally, commit, and push again. Your PR automatically updates.

Self-review your pull request

Before a maintainer sees your work, review it yourself. This catches embarrassing mistakes and shows professionalism.

  • Open the Files changed tab on your pull request page.
  • Read your own diff line by line.
  • Check for debug code like print() statements or commented-out code. Remove them.
  • Check for unrelated changes such as whitespace fixes or import reordering you did not intend.
  • Verify consistent naming with the rest of the codebase.
  • Confirm every new branch of logic has a corresponding test.

Why self-review matters for first contributions

Maintainers often triage PRs by scanning the diff for red flags. A PR with leftover debug code or unrelated changes signals a careless contributor and gets deprioritized. A clean diff signals someone who respects the reviewer's time.

Secret mission

Navigate Your First Code Review

Your PR is submitted, but the journey is not over. Most first contributions go through 3-5 rounds of review before being merged. Can you respond to maintainer feedback professionally and get your code merged into one of the most popular AI repositories on GitHub?

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally and on free GitHub infrastructure, so there are no ongoing costs. Decide whether to keep your resources available for future contributions, or clean them up to free disk space.

Resources you used:

  • A fork of langchain-ai/langchain on your GitHub account (free, no cost).
  • A local clone of the LangChain repository with Poetry dependencies installed (disk space only).
  • Poetry installed on your system (installed in Step 1).

Keep everything running

No action needed. Choose this if you plan to continue contributing to LangChain or other projects that use Poetry.

  • Your fork stays on GitHub indefinitely at no cost. It also shows your merged contribution in your profile history.
  • Your local clone stays on disk and is ready for your next contribution. You can create a new branch anytime.
  • Poetry remains available for any Python project that uses it as a dependency manager.

Pause - I'll come back to this later

Free up disk space while keeping your fork on GitHub so you can re-clone anytime.

  • Delete the local langchain directory from your Desktop to reclaim disk space. You can re-clone from your fork whenever you want to contribute again.
  • Keep your GitHub fork. It costs nothing and preserves your contribution history.
  • Keep Poetry installed. It takes minimal space and is useful for other Python projects.

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow these steps to fully clean up.

  • Delete the local clone by running this command in your terminal:

macOS

rm -rf ~/Desktop/langchain

Windows

Remove-Item -Recurse -Force ~\Desktop\langchain
  • Delete your GitHub fork:
  • Navigate to your fork at github.com/YOUR-USERNAME/langchain.
  • Click Settings (under your repository name).
  • Scroll down to the Danger Zone section.
  • Click Delete this repository.
  • Click I want to delete this repository.
  • Click I have read and understand these effects.
  • Type the repository name to confirm, then click Delete this repository.

Will deleting my fork remove my contribution?

No. Your merged pull request lives on the upstream langchain-ai/langchain repository permanently. Deleting your fork only removes your personal copy. Your contribution and commit history on the main repo remain intact.

  • Uninstall Poetry by re-running the installer with the uninstall flag:

macOS

curl -sSL https://install.python-poetry.org | python3 - --uninstall

Windows

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python - --uninstall

Nice Work!

Nice Work!

You just contributed real code to LangChain, one of the most popular open source AI repositories with 135K+ stars. Your merged pull request is now part of your public developer profile on GitHub.

You've learned how to:

  • Evaluated a project's contribution readiness by reading its CONTRIBUTING.md, browsing merged PRs, and finding a beginner-friendly issue using GitHub's issue search.
  • Forked a 135K+ star repository, configured upstream tracking, and set up a Poetry-based development environment with passing tests and linting.
  • Submitted a professional pull request with a structured description linking the issue, passing CI, and following the project's conventional commit style.
  • Secret Mission: Responded to maintainer code review feedback professionally and iterated until your PR was merged.

Ready to quiz yourself?