DEV Community: Hiroyuki Kuromiya

Extract metadata of paper and export it to Notion DB

Hiroyuki Kuromiya — Wed, 18 Dec 2024 02:50:25 +0000

I recently developed a chrome extension named "Paper to Notion."

Paper to Notion - Chrome Web Store

A Chrome extension that imports paper metadata from Crossref to Notion using a DOI.

chromewebstore.google.com

Once you input the DOI of the paper, it automatically export it to your Notion DB.

https://youtu.be/Pg0eNnxyVTI?si=WsfSqV-gT2FhWHFg

Structure is very simple: it calls Crossref API to retrieve metadata and uses Notion API to conntect the database.

I used the chrome extension development framework, WXT, which made the development much more easier.

With tagpr, it generates the release zip file automatically, once I pushed any changes to the main branch.

My GitHub Actions workflow file is here:

name: Release

on:
  push:
    tags:
      - 'v*'

jobs:
  build-and-release:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '22'

      - name: Install dependencies
        run: npm install

      - name: Build and zip
        run: npm run zip

      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: ${{ github.ref }}
          release_name: Release ${{ github.ref }}
          draft: false
          prerelease: false

      - name: Strip 'v' prefix from version
        id: strip_v
        run: echo "version=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV

      - name: Upload Release Asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: .output/paper2notion-${{ env.version }}-chrome.zip
          asset_name: paper2notion-${{ env.version }}-chrome.zip
          asset_content_type: application/zip

Feel free to post any issues and pull requests. I published the extension as OSS!

https://github.com/kromiii/paper-to-notion

How to Set Up a Slack Bot for SQL Query Generation with tbls-ask-agent-slack

Hiroyuki Kuromiya — Tue, 24 Sep 2024 11:40:55 +0000

Introduction

A while back, I created a Slack App called tbls-ask-agent-slack. In short, it's a Slack Bot that generates SQL queries based on natural language requests. I introduced it in my company's tech blog (in Japanese), and it gained some attention. However, I didn't provide detailed setup instructions, so I'd like to share a step-by-step guide here.

In this tutorial, we'll set up the bot and try generating queries for a sample database schema right from Slack.

Preparation

First, clone the repository:

ghq get git@github.com:kromiii/tbls-ask-agent-slack.git

(I use the ghq command, but feel free to use git clone if you prefer.)

Next, create a Slack App:

Go to https://api.slack.com/apps
Click "Create New App" and choose "From an app manifest"
Select your workspace
When prompted for the manifest, copy and paste the contents of the manifest.yml file from the cloned repository

Setting Up Environment Variables

You'll need to set three environment variables:

OPENAI_API_KEY: Your OpenAI API key
SLACK_APP_TOKEN: Slack App token
SLACK_OAUTH_TOKEN: Slack OAuth token

Create an .envrc file by copying the sample:

cp .envrc.sample .envrc

Edit .envrc and add your OpenAI API key:

export OPENAI_API_KEY=sk-***

For the Slack tokens:

Go to your Slack App's settings
Under "OAuth & Permissions", copy the token starting with xoxb- and set it as SLACK_OAUTH_TOKEN
Under "Basic Information", copy the App-Level token starting with xapp- and set it as SLACK_APP_TOKEN

Setting Up the Sample Schema

tbls-ask-agent-slack requires a database schema file generated by tbls. For this tutorial, we'll use a sample schema:

cp schemas/config.yml.sample schemas/config.yml

If you need to reference files from a private repository, you can add a GITHUB_TOKEN to your environment variables.

Running the Bot

With everything set up, run the bot:

go run main.go

When you see "Connected to Slack with Socket Mode.", the bot is ready.

Invite the bot to a Slack channel and mention it.

It will prompt you to choose a schema (select "wordpress" for this example).

After a short wait, it will respond with an explanation and the requested SQL query.

Conclusion

That's it! You've successfully set up and run tbls-ask-agent-slack. For those looking to deploy it in a production environment, I've provided Kubernetes manifest files in the repository:

https://github.com/kromiii/tbls-ask-agent-slack/blob/main/manifests/deployment.yml

Feel free to use and modify them as needed. Happy querying!

Today I Learned: An App to Capture Your Daily Learning from LLM Chats

Hiroyuki Kuromiya — Sat, 21 Sep 2024 01:42:16 +0000

Introduction

I'm excited to introduce "Today I Learned" (TIL), an app I've developed to help you capture and reflect on your daily learning experiences.

today-i-learned.app

My TIL app automatically summarizes "what you've learned today" from your chat history with Large Language Models (LLMs) and presents it in a user-friendly dashboard for easy review. To get a quick overview of how it works, check out this demo video:

The Journey Behind TIL

My journey as a full-time web engineer began in the spring of 2023. Prior to that, I spent a decade in academia, focusing on educational technology research. During that time, I developed learning support tools, including dashboards for students.
After transitioning to the tech industry, I was fascinated by the unique culture of software engineering. One aspect that particularly caught my attention was the concept of "Today I Learned" (TIL).

While daily reports are common in many professions, I noticed that engineers often shared not just what they did, but what they learned. Inspired by this, I started adding a "What I Learned Today" section to my own reports. Little did I know, I was participating in the broader TIL culture of the tech world.

Understanding TIL

The TIL concept dates back to around 2008, originating from a "today-i-learned" topic on Reddit. It gained traction in the software development community, with developers creating "til" repositories on GitHub to document their daily learnings in Markdown format. Josh Branchaud's repository played a significant role in popularizing this practice.

The essence of TIL is beautifully captured in Reddit's TIL topic description:

"TIL does not aim for in-depth and serious discussion about a subject, but rather is more interested in a pop-knowledge overview of some minutiae of a field."
In other words, TIL is about sharing those "aha!" moments and bite-sized learnings, regardless of how profound or trivial they might seem.

How the TIL App Works

Now, let me walk you through the technical aspects of the TIL app:

The app is built with NextJS and hosted on Vercel
Firestore serves as the knowledge storage backend
User authentication is handled by Firebase Authentication

For the crucial task of extracting knowledge from chat histories, I leveraged the OpenAI API. The core logic resides in the digest API file, where I use the following prompt to distill the user's learnings:

const completion = await openai.beta.chat.completions.parse({
 model: "gpt-4o-2024–08–06",
 messages: [
 {
 role: "system",
 content:
 "Extract what the user learned from the chat to the bot in 100 words. Provide the response in plain text without using any markdown formatting. Use the same language as the user's input for the summary.",
 },
 …messages,
 ],
 response_format: zodResponseFormat(Knowledge, "knowledge"),
});

This two-stage LLM process might seem redundant, but using chat as the source of knowledge extraction offers a clear picture of what the user was seeking to learn.

Closing Thoughts: Why an English Interface?

You might notice that the TIL app's interface is entirely in English although I am Japanese. This decision stems from two factors:

TIL culture originated in the United States, and I wanted to make the app accessible to a global audience.
My academic experience taught me that, unfortunately, work published solely in Japanese often struggles to gain recognition on the global stage.

The source code is open and available on GitHub. Feel free to localize, self-host, or contribute to the project. I welcome any issues or pull requests you might have!

kromiii / today-i-learned

Today I Learned - AI-Powered Learning Assistant

Today I Learned is an AI-powered learning support tool that helps you record daily discoveries, interact with AI, and track your learning progress.

Features

Ask AI: Interact with an AI assistant to get answers on any topic.
Automatic Learning Summary: Summarize and organize your learnings from AI interactions.
Learning Dashboard: Visualize your daily learning progress and growth.
User Authentication: Secure sign-in with Google.

Technology Stack

Next.js: React framework for building the frontend and API routes.
Firebase: Authentication and Firestore database.
OpenAI: AI-powered chat functionality.
Tailwind CSS: Utility-first CSS framework for styling.
Chart.js: Creating interactive charts for the dashboard.

Getting Started

Clone the repository:

git clone https://github.com/yourusername/today-i-learned.git cd today-i-learned

Install dependencies:

npm install

Set up environment variables: Create a .env.local file in the root directory and add the following variables:

NEXT_PUBLIC_FIREBASE_API_KEY=your_firebase_api_key NEXT_PUBLIC_FIREBASE_AUTH_DOMAIN=your_firebase_auth_domain NEXT_PUBLIC_FIREBASE_PROJECT_ID=your_firebase_project_id NEXT_PUBLIC_FIREBASE_STORAGE_BUCKET=your_firebase_storage_bucket NEXT_PUBLIC_FIREBASE_MESSAGING_SENDER_ID=your_firebase_messaging_sender_id NEXT_PUBLIC_FIREBASE_APP_ID=your_firebase_app_id OPENAI_API_KEY=your_openai_api_key

Run the…

View on GitHub

By embracing the TIL concept and leveraging the power of LLMs, this app aims to make your daily learning more tangible and reflective. I hope you find it useful in your own learning journey!

Introducing a CLI Tool for Automatically Detecting Unused Unleash Flags

Hiroyuki Kuromiya — Thu, 19 Sep 2024 11:41:44 +0000

Hello everyone! Today, I'd like to introduce a CLI tool I developed that automatically detects unused Unleash flags. By using this tool, you can easily identify outdated feature flags in your project and help clean up your codebase.

Tool Overview

Repository: stale-flag-detector
Function: Automatically detects unused Unleash flags
Installation: Clone the repository and generate the executable using the go build command

Basic Usage

After building the tool, you can display a list of stale flags by running it as follows:

% ./stale-flag-detector
Stale flags:
- unleash-ai-example-stale
- another-stale-flag

Options

This tool has two main options:

--exclude-potentially-stale-flags
- Excludes potentially stale flags from the results
- For more details on potentially stale flags, please refer to the Unleash documentation
--output-regex
- Outputs the results in regex format

Example of Regex Output

% ./stale-flag-detector --output-regex
(unleash-ai-example-stale|another-stale-flag)

Practical Usage Example

The true value of this tool is realized when combined with other command-line tools. For example, by combining it with the pt command (The Platinum Searcher), you can easily identify where stale flags are being used in your project:

% pt -e `./stale-flag-detector --output-regex` ../sample-app-for-unleash-checker
../sample-app-for-unleash-checker/app/stale.py
9:if client.is_enabled("unleash-ai-example-stale"):

Using this method provides the following advantages:

Accurately locate unused flags
Simplify codebase cleanup
Contribute to reducing technical debt

Summary

The stale-flag-detector is a powerful tool for streamlining the maintenance of projects using Unleash. It can help improve feature flag management and keep your codebase clean. Give it a try!

If you have any feedback or suggestions for improvement, please let us know through Issues or Pull Requests on the GitHub repository. We look forward to hearing your opinions!

Experimenting with AI-Scientist: An AI-Powered Paper Review Tool

Hiroyuki Kuromiya — Sun, 18 Aug 2024 03:45:56 +0000

Experimenting with AI-Scientist: An AI-Powered Paper Review Tool

As a researcher, I'm always intrigued by new tools that can enhance the academic process. Recently, I came across an interesting project called AI-Scientist, developed by Sakana AI. This tool promises to review academic papers using artificial intelligence. Curious about its capabilities, I decided to put it to the test with a couple of my own published papers.

Setting Up the Environment

I followed the setup process outlined in a blog post and the official GitHub repository. Here's a quick rundown of the steps:

1. Clone the repository:

   git clone https://github.com/SakanaAI/AI-Scientist.git

2. Install the required dependencies:

   pip install -q anthropic aider-chat backoff openai
   pip install -q pypdf pymupdf4llm
   pip install -q torch numpy transformers datasets tiktoken wandb tqdm

According to the official documentation, texlive-full is required to generate papers, but it is very heavy to use colab.
I just wanted to request a review this time, so skipping it didn't seem like a problem.

3. Set up the OpenAI API key (I used Google Colab's userdata for this):

   import os
   from google.colab import userdata
   api_key = userdata.get('OPENAI_API_KEY')
   os.environ['OPENAI_API_KEY'] = api_key

Running the AI Review

With the environment set up, I was ready to test the AI-Scientist on my papers. I used the following code to perform the review:

import openai
from ai_scientist.perform_review import load_paper, perform_review

client = openai.OpenAI()
model = "gpt-4o-mini-2024-07-18"

paper_txt = load_paper("my-paper.pdf")
review = perform_review(
    paper_txt,
    model,
    client,
    num_reflections=5,
    num_fs_examples=1,
    num_reviews_ensemble=5,
    temperature=0.1,
)

The Results

I tested the AI-Scientist on two of my published papers:

Surprisingly, both papers received a "Reject" decision from the AI reviewer, with overall scores of 4 out of 10. Here's a summary of the feedback for the first paper:

Strengths:

Addresses a relevant topic of Learning Analytics in K-12 education
Identifies distinct engagement patterns
Provides empirical data on students' engagement and performance

Weaknesses:

Lack of methodological details
Insufficient address of potential confounding factors
Limited discussion on broader implications
Inconsistent clarity in writing

Questions posed by the AI:

Requests for more details on clustering methodology
Inquiries about addressing limitations in future work

The feedback for the second paper was similar, highlighting strengths in addressing significant educational issues but pointing out weaknesses in methodology and validation.

Reflections

While it's disheartening to see my published works receive "Reject" decisions from the AI, it's important to consider a few factors:

The AI might be calibrated to very high standards, possibly aiming for top-tier conference or journal quality.
The tool provides valuable feedback that could be used to improve papers before submission.
This experiment demonstrates the potential of AI in academic review processes, but also highlights the need for human judgment in interpreting results.

As we continue to integrate AI tools into academic workflows, it's crucial to view them as assistants rather than replacements for human reviewers. They can offer quick, initial feedback, but the nuanced understanding of research context and significance still requires human expertise.

Have you experimented with AI tools in your research process? I'd love to hear about your experiences in the comments!

Using Notion as a Presentation Tool

Hiroyuki Kuromiya — Sun, 05 Nov 2023 10:28:14 +0000

Notion is a powerful tool to organize knowledge and share it others.

For me, Notion is a presentation tool as well as the content management tool.

Here is the simple description of my npm package named notion-to-slides.

notion-to-slides: convert notion page to presentation slides - Speaker Deck

speakerdeck.com

Amazingly, this slides is also made by notion.

You can convert the Notion page to a presentation by just a single command.



$ npx @kromiii/notion-to-slides --url [your notion page url] --theme [marp theme]

H1 and H2 Heading in the notion page will be used as the slide title, and the rest of the content will be used as the slide body.

There are two advantages of using notion as a presentation tool.

Your slides become simple, which means readers can easily understand the points you want to say.
You can make the slides intuitively compared to directly editing the markdown file.

Currently, we have a famous chrome plugin published by Wunderpresentation, but it sometimes fail to embed images.

That is the motivation to develop this package, and it will save the people who have the same problem as me.

Enjoy.

I noticed that we can use DALL·E from CLI

Hiroyuki Kuromiya — Wed, 18 Oct 2023 23:28:36 +0000

Hello, this is my first post!

Yesterday, I tried 1password openai plugin.

Then, I noticed that we can use openai command from command line.

Here are the example.

% openai api completions.create -m ada -p "I have two eggs, and"
I have two eggs, and I'll get you a fourth, now have some breakfast, too!"

What is wonderful is that we can create image from cli!

% openai api image.create -p "a man playing music in a bar" -n 1

The result is here.

Looks nice!