alab-opensource-finder

"An AI-powered GitHub issue discovery tool that turns natural-language requirements into relevant, ranked, contribution-ready open-source issues.”

Comment

Inspiration

The idea for Alab Open Source Finder came from a problem I personally experienced.

One Friday night, around 9 PM, I decided to spend my weekend contributing to open-source AI projects. I opened GitHub and started searching for issues that matched my interests and technical skills.

9 PM turned into 10 PM, then 11 PM, midnight, and eventually 1 AM.

I had gone through more than 1,500 GitHub issues, yet I struggled to find just 6 issues that were genuinely relevant to what I wanted to contribute to.

That experience made me realize:

Finding the right open-source issue can sometimes take more time than actually solving it.

The problems were familiar: issues with limited context, issues written in unfamiliar programming languages, issues that didn't match my technical interests, and issues that were either too complex or too simple for my current experience level.

Instead of spending another weekend manually searching through GitHub, I decided to build a solution for the problem.

What it does

Alab Open Source Finder is an AI-assisted GitHub issue discovery tool that helps developers find relevant, contribution-ready open-source issues using natural-language requirements.

A developer can simply describe what they are looking for, for example:

"Find me 5 good first issues related to RAG in Python."

The system then processes the request through a structured workflow:

User Requirement → Intent Understanding → Search Strategy → GitHub Search → Issue Filtering → Scoring → Ranking → Top Recommendations

It evaluates issues based on factors such as:

  • Requirement relevance
  • Topic relevance
  • Programming language
  • Issue type
  • Difficulty or complexity
  • Available GitHub metadata

Instead of manually reviewing hundreds or thousands of GitHub issues, developers receive a focused list of the most relevant opportunities.

The application also supports conversational follow-ups such as:

  • "Give me more"
  • "Find me easier ones"
  • "Give me harder issues"
  • "Find me JavaScript issues instead"

The goal is simple:

Reduce the time developers spend searching for open-source issues and increase the time they spend actually contributing.

How we built it

We built Alab Open Source Finder as a structured AI workflow using LangGraph.

The workflow consists of multiple specialized stages:

  1. Intent Understanding
    The LLM analyzes the user's natural-language requirement and identifies important preferences.

  2. Search Strategy
    The interpreted requirements are converted into an appropriate GitHub search strategy.

  3. GitHub Search
    The application retrieves real GitHub issue data through the official GitHub MCP Server.

  4. Issue Filtering
    Retrieved issues are validated and filtered based on the user's requirements.

  5. Scoring & Ranking
    Deterministic Python logic calculates relevance scores and ranks the candidate issues.

  6. Top Issue Selection
    The highest-ranked issues are selected for the final response.

  7. Response Generation
    The results are presented to the user as structured issue recommendations.

A key design decision was separating LLM-based reasoning from deterministic application logic.

We use the LLM primarily for understanding user intent, while Python handles validation, filtering, scoring, ranking, and result selection. This makes the system more predictable and easier to test.

Technology Stack

  • LangGraph — workflow orchestration
  • Groq — LLM-based requirement understanding
  • GitHub MCP Server — real GitHub issue retrieval
  • Python — filtering, scoring, ranking, and core logic
  • FastAPI — backend API
  • HTML / CSS / JavaScript — frontend
  • Docker — MCP server runtime

Challenges we ran into

One of the biggest challenges was deciding what should be handled by the LLM and what should be handled by deterministic code.

We wanted the system to understand flexible natural-language requirements, but we also wanted the final recommendations to be consistent and explainable.

This led us to separate the workflow into two major parts:

LLM → Understand the user's intent

Python → Validate, filter, score, and rank the results

Another challenge was integrating GitHub through MCP while ensuring that issue information came from actual GitHub data rather than being generated by the LLM.

We also had to handle practical engineering challenges such as:

  • GitHub rate limits
  • MCP and Docker availability
  • Input validation
  • Retry behavior
  • Conversation state
  • Ranking consistency
  • External service failures
  • Keeping API credentials isolated from the main application logic

The current implementation stores conversation state in memory, which also means state is reset when the server restarts.

Accomplishments that we're proud of

We are particularly proud that this project started from a real problem we personally experienced and evolved into a working AI-powered developer tool.

Some accomplishments we're proud of include:

  • Built a complete LangGraph-based AI workflow
  • Successfully integrated the official GitHub MCP Server
  • Grounded GitHub issue information in real GitHub data
  • Combined LLM reasoning with deterministic Python logic
  • Implemented requirement-based issue filtering
  • Built a deterministic relevance scoring and ranking system
  • Added conversational follow-up capabilities
  • Built a FastAPI backend and browser-based frontend
  • Added automated tests for core workflow behavior and external-service interactions
  • Designed the system so individual workflow stages can be tested, debugged, and extended independently

Most importantly, we turned a problem that once took hours of manual GitHub searching into a workflow designed to quickly surface relevant contribution opportunities.

What we learned

This project taught us that building useful AI applications is not just about connecting an LLM to a few tools.

The most important lesson was learning how to design a system where AI reasoning and deterministic software logic complement each other.

We learned how to:

  • Build structured workflows with LangGraph
  • Integrate external capabilities using MCP
  • Work with real-world GitHub data
  • Design relevance scoring and ranking systems
  • Use LLMs for intent understanding
  • Build APIs with FastAPI
  • Run MCP infrastructure with Docker
  • Handle external-service failures and retries
  • Design conversational workflows with state
  • Think about security and credential isolation
  • Write tests around AI workflows and external integrations

We also learned that solving a real problem first can lead to much better AI projects than starting with a technology and searching for a problem afterward.

What's next for alab-opensource-finder

Alab Open Source Finder is currently an MVP, and there are several areas we want to improve.

Our next steps include:

  • Contributor-profile matching — match issues with a developer's skills and experience
  • Persistent conversation state — maintain conversations across server restarts
  • Improved issue-quality scoring — better evaluation of issue quality and contribution readiness
  • Repository-level ranking — identify high-quality repositories alongside individual issues
  • Duplicate and similar-issue detection
  • Experience-level recommendations — recommend issues based on beginner, intermediate, or advanced experience
  • Configurable ranking criteria — allow developers to customize what matters most
  • Advanced observability and tracing
  • Production deployment
  • Expanded automated test coverage

The long-term vision is to make Alab Open Source Finder a personal open-source contribution assistant that understands a developer's skills and interests and continuously helps them discover meaningful opportunities to contribute.

Spend less time finding the right issue. Spend more time actually contributing.

Built With

Share this project:

Updates

Submission history