DEV Community: Izawa

An Agent Skill that changes your question instead of answering it

Izawa — Sat, 25 Jul 2026 17:03:26 +0000

Ask any assistant an open-ended question — should I build this, should I take this job, how do I position this product — and you get advice that is reasonable and slightly generic. Narrow the target. Differentiate. Build an MVP. Talk to users. Test demand.

None of it is wrong. It just never moves where you are standing.

Insight Compiler is an Agent Skill I published that treats that generic answer as the starting line instead of the finish. It writes the ordinary answer down explicitly, then spends the rest of the run climbing off it.

The loop

The skill runs seven steps every time:

Intent discovery — separates the surface question from the real goal, and names the question you haven't asked
Ordinary-answer baseline — writes out what a normal AI would say, explicitly
Domain lenses — looks at the problem through distant fields: military strategy, urban design, game design, religion, investment
Discovery operators — deforms the problem: invert it, swap who acts, shift the scale, hunt for the hole nobody is looking at
Hint bank — crosses lenses with operators into a dense list of raw material
Strategy candidates — 2-3 directions, each traced back to the specific hints it came from
Honest evaluation + one validation fork — ranks them without manufacturing a tie, then commits in advance to what each test outcome should change

Step 2 is the load-bearing one. An unstated ordinary answer is a ceiling the model quietly settles into; a written-down one is a floor you can push off. Step 7 is what keeps the whole thing from being a brainstorm — you end with one cheap test and a decision already made for either result.

The internal scan is wide, but the output is curated. It shows the strongest findings rather than dumping every lens it tried.

What it looks like in practice

Here is a real run. The question I gave it was my own, and it is a small one, which makes it a good demo — I published this skill and nobody was visiting the repository, so I asked what to do about it.

A plain assistant answered the question as asked: add more examples to the README, record a GIF, post it to X and Reddit, get the content ready before announcing. Solid, actionable, and it accepts every premise in the question.

The skill opened by rejecting the question:

Essential question: Not "how do I get more repo visitors," but "where does the target person first encounter enough value to feel something move in their thinking?"

Why this is non-obvious: The premise "low visits = insufficient explanation" conflates two different bottlenecks — the discovery/distribution problem and the comprehension problem.

Then, near the end, the assumption I hadn't noticed I was making:

The assumption that "GitHub repo visitor count" is the correct success metric, and that "hard to understand" is the cause of low interest, is itself questionable. For an agent skill that runs inside Claude, the person deciding whether to adopt it may never need to visit the repo at all — if they encounter a compelling output first.

Side by side:

Ordinary answer	Insight Compiler
Improve the README	Decide who it is for, first
Add 3-5 demos	Produce one complete example that lands with one person
Announce on social media	Distribute the output itself as the content
Grow visitor count	Create the first repeat user

It also graded its own three candidates honestly — flagging its most interesting one as "unverified whether target readers are actually where you post," and admitting the boring README fix was the only one executable today. The verdict: do the boring one because it is nearly free, but it is necessary, not sufficient.

The full transcript is in the repo, unedited, both answers side by side. It is long — that is the honest shape of the output, not a teaser.

Installing it

An Agent Skill is just a directory with a SKILL.md in it. For Claude Code:

git clone https://github.com/snc2work/insight-compiler.git
mkdir -p ~/.claude/skills
cp -r insight-compiler/InsightCompiler ~/.claude/skills/

Restart, then /skills to confirm it loaded. Any agent that supports Agent Skills works the same way — copy the directory, keeping SKILL.md and references/ together.

You never invoke it by name. It triggers on the shape of the question:

Let me consult you on something. I'm deciding whether to quit my job to
build my own product.

Users are complaining about our paid plan. Should we lower the price?

I have an idea for a product, but I'm not sure it's different enough from
what's already out there.

There is a second version, InsightCompilerPersonal, that keeps a local profile at ~/.insight-compiler/profile.md. It records only working habits — your known constraints, whether you actually run the validations you agree to, the angle you always enter from — and never which ideas you liked, so it grounds the executability judgment without building you an echo chamber. Install one or the other, not both; they trigger on the same prompts.

When not to use it

A full session is thousands of words. That length is deliberate, and it makes this the wrong tool whenever you want a quick factual answer, some code, or a decision you can act on in the next five minutes.

It also cannot check reality. When it says a market gap exists, that is a hypothesis produced by reasoning, not research. Treat novelty claims as things to go verify.

And if you already know what you are doing and just need it done, an ordinary answer is the correct answer. This skill is for the questions where you suspect you are solving the wrong problem.

One note on the example

There is something circular about the demo above, and it is worth saying out loud: the run told me to stop polishing the repository and put a finished output where readers already are. This post is that instruction being carried out. Whether it worked is measurable, and the session pre-committed to what each outcome means — reaction means keep producing transcripts, silence means the problem is not presentation and I should go narrow with one real user instead.

Repository: https://github.com/snc2work/insight-compiler (MIT)

If you try it, I would like to know what you pointed it at.

Auto-Backup Your Git Repo on Every Commit

Izawa — Tue, 24 Feb 2026 18:15:14 +0000

AI coding tools are great, but there's a non-zero chance one of them nukes your .git folder someday. Scheduled backups work, but I wanted something that just happens automatically — so I set up a bare repository on a separate drive that syncs on every commit via a post-commit hook. Here's how. (macOS, but Linux is identical.)

Step 1: Create the bare repository

Pick somewhere outside your project — an external drive works well.

mkdir -p /path/to/backup/project.git
cd /path/to/backup/project.git
git init --bare

A bare repo stores only history, no working files. Same format GitHub uses internally.

Step 2: Register it as a remote

cd ~/path/to/project

git remote add backup /path/to/backup/project.git

# Initial push (check your branch name first)
git branch --show-current
git push backup <branch-name>

# Verify
git ls-remote backup

Step 3: Add the post-commit hook

touch .git/hooks/post-commit
chmod +x .git/hooks/post-commit

.git/hooks/post-commit:

#!/bin/sh
current_branch=$(git rev-parse --abbrev-ref HEAD)
git push backup "$current_branch" --quiet >/dev/null 2>&1 &

The & runs it in the background so commits don't feel any slower.

Verifying it works

touch backup_test.txt
git add backup_test.txt
git commit -m "test: post-commit hook"

Then compare hashes:

git log --oneline -1
git ls-remote backup

If main points to the same hash in both, you're good. Clean up:

git rm backup_test.txt
git commit -m "chore: remove test file"

Recovery

If only .git was deleted (files intact):

cd /path/to/project
git init
git remote add backup /path/to/backup/project.git
git fetch backup
git branch -r  # confirm branch name
git reset --mixed backup/<branch-name>
git status     # commit any remaining diff

If the whole folder is gone:

git clone /path/to/backup/project.git my_project

In both cases, re-add the post-commit hook afterward since .git/hooks/ isn't tracked by Git.

That's it. A bit of setup, but once it's running you don't think about it again.

Getting Started with LangChain

Izawa — Tue, 27 Feb 2024 09:59:52 +0000

Introduction

An introduction to how to use Langchain.
Basic writing with LCEL will be introduced.
The model used was gpt-3.5-turbo.

Reference Documents

Official Documents
https://python.langchain.com/docs/get_started/quickstart
LCEL
https://python.langchain.com/docs/expression_language/

Setup

Install

python -V
Python 3.11.6

pip install python-dotenv

pip install langchain
pip show langchain
Version: 0.1.9

pip install langchain-openai
pip show langchain-openai
Version: 0.0.7

pip install langchain-core
pip show langchain-core
Version: 0.1.27

Create File
Create a directory (e.g. test_langchain)

/test_langchain/.env
/test_langchain/test.py

ENV file
Set your OpenAI API Key.

OPENAI_API_KEY="***********"

Sample code

test.py

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

load_dotenv()
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
llm = ChatOpenAI(openai_api_key=OPENAI_API_KEY, model="gpt-3.5-turbo", temperature=0)

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a culinary expert"),
        ("user", "{input}"),
    ]
)

output_parser = StrOutputParser()

# LCEL
chain1 = prompt
chain2 = prompt | llm
chain3 = prompt | llm | output_parser

response1 = chain1.invoke({"input": "Speaking of good Japanese food, name one."})
print(response1)
print("------------")
response2 = chain2.invoke({"input": "Speaking of good Japanese food, name one."})
print(response2)
print("------------")
response3 = chain3.invoke({"input": "Speaking of good Japanese food, name one."})
print(response3)
print("------------")

Execute from a terminal.
python test.py

Output Result
Results are displayed for each pattern.
If StrOutputParser() is used, the value of response is the response statement only.

messages=[SystemMessage(content='You are a culinary expert'), HumanMessage(content='Speaking of good Japanese food, name one.')]
------------
content='One popular Japanese dish is sushi. Sushi is a dish that typically consists of vinegared rice topped with various ingredients such as raw fish, seafood, vegetables, and sometimes tropical fruits. It is often served with soy sauce, wasabi, and pickled ginger. Sushi can be enjoyed in many different forms, such as nigiri (sliced fish on top of rice), sashimi (sliced raw fish without rice), maki (rolled sushi), and temaki (hand-rolled sushi).'
------------
One popular Japanese dish is sushi. It typically consists of vinegared rice topped with various ingredients such as raw fish, seafood, vegetables, and sometimes tropical fruits. Sushi is not only delicious but also visually appealing, making it a favorite choice for many people around the world.
------------

Conclusion

This time I used ChatGPT and tried a simple description using LCEL.

Langchain is updated frequently, so it is recommended that you check it regularly.

How to Use Microsoft AutoGen

Izawa — Wed, 18 Oct 2023 18:46:14 +0000

Introduction

I tried AutoGen, an open source software published by Micorsoft.

https://github.com/microsoft/autogen

Reference Documents

Official Documents
https://microsoft.github.io/autogen/docs/getting-started

FAQ
https://microsoft.github.io/autogen/docs/FAQ/

Multi-agent Conversation Framework
https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat/

Sample code

This time, considering the cost, I experimented with only gpt-3.5-turbo, with multiple agents just chatting. We also set max_round=4 for the number of conversations.

install
Python version >= 3.8

pip install pyautogen
Name: pyautogen
Version: 0.2.15

Create File
Create a directory (e.g. test_autogen)

/test_autogen/OAI_CONFIG_LIST
/test_autogen/app/test.py

OAI_CONFIG_LIST
Do not add extensions to file names.
Describe OpenAI's API KEY information.
For an overview of LLM configurations and other implementation methods, please see below.
https://microsoft.github.io/autogen/docs/llm_configuration/

[
  {
    "model": "gpt-3.5-turbo-1106",
    "api_key": ""**********""
  },
  {
    "model": "gpt-3.5-turbo-0125",
    "api_key": "**********"
  }
]

test.py

import autogen

# OAI_CONFIG_LIST
config_list_gpt = autogen.config_list_from_json(
   "OAI_CONFIG_LIST",
   file_location="..",
   # optional
   # filter_dict={
   #     "model": {
   #         "gpt-3.5-turbo-0125",
   #     }
   # },
)

llm_config = {
   "config_list": config_list_gpt,
   "seed": 10,
   "temperature": 0.7,
}

# This time, we experimented without using user_proxy.
# user_proxy = autogen.UserProxyAgent(
#     name="User_proxy",
#     system_message="A human admin.",
#     code_execution_config={"last_n_messages": 2, "work_dir": "groupchat"},
#     human_input_mode="TERMINATE",
# )
agent_a = autogen.AssistantAgent(
    name="Agent-A",
    system_message="You love French food.",
    llm_config=llm_config,
)
agent_b = autogen.AssistantAgent(
    name="Agent-B",
    system_message="You love Japanese food!",
    llm_config=llm_config,
)
agent_c = autogen.AssistantAgent(
    name="Agent-C",
    system_message="You love Chinese food!",
    llm_config=llm_config,
)

groupchat = autogen.GroupChat(
    agents=[agent_a, agent_b, agent_c], messages=[], max_round=4
)
manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=llm_config)

manager.initiate_chat(manager, message="Chatting about food.")

Execute from a terminal.
python test.py

Output Result
Conversations were generated up to the specified number of times.

python test.py
chat_manager (to chat_manager):

Chatting about food.

--------------------------------------------------------------------------------
Agent-A (to chat_manager):

Yes, I absolutely love French food! The rich flavors, delicate techniques, and exquisite presentation of French cuisine never fail to impress me. From classic dishes like coq au vin and boeuf bourguignon to the indulgent pastries like croissants and macarons, French food is a true delight for the senses. The use of fresh, high-quality ingredients and the emphasis on balance and harmony in flavors make every bite a memorable experience. Whether it's a simple bistro meal or a fancy Michelin-starred restaurant, French food always brings me joy.

--------------------------------------------------------------------------------
Agent-B (to chat_manager):

That sounds absolutely delicious! French cuisine is renowned for its elegance and sophistication. The way they elevate simple ingredients into masterpieces is truly remarkable. The buttery croissants, rich sauces, and perfectly cooked meats are just a few examples of the culinary excellence that French cuisine offers. It's no wonder that French food is considered one of the finest in the world. Do you have a favorite French dish?

--------------------------------------------------------------------------------
Agent-C (to chat_manager):

It's hard to choose just one favorite French dish, but if I had to pick, it would probably be coq au vin. The tender chicken braised in red wine with onions, mushrooms, and herbs is simply divine. The flavors are rich and complex, and the dish is incredibly comforting. It's a classic French dish that never fails to impress. How about you? Do you have a favorite French dish?

Conclusion

GroupChat was easy to implement with sample code.

This time it was just a conversation between AIs with no particular meaning, but there are several examples of using GPT-4, such as automatic task resolution for code generation, so it seems that something interesting can be created.

Implement ThirdWeb Smart Wallet and Embedded Wallet in Next.js

Izawa — Thu, 05 Oct 2023 12:44:23 +0000

Introduction

ThirdWeb's Wallet feature is extensive and convenient. In this case, I tried the Smart Wallet and Embedded Wallet.

Prerequisites

Experience with Next.js development
Experience with Thirdweb dashboard

Preparation (from Thirdweb dashboard)

Thirdweb
https://thirdweb.com/

Step (chain uses Mumbai)

Create API Keys from Settings
Create a Smart wallet Account Factory from Explore in Contracts
Setup Wallet and generate code from Connect in Wallets

1. Create API Keys from Settings

2. Create a Smart wallet Account Factory from Explore in Contracts
Selecting and creating an Account Factory

Check what has been created.
This contract address is required as factoryAddress when implementing the page.

3. Setup Wallet and generate code from Connect in Wallets
In this case, I chose MetaMask, Embedded Wallets and Smart Wallet.
(To use Smart Wallet, select at least one Wallet)
The code generated here will be used as a reference for implementation.

Generated Code

import {
  ThirdwebProvider,
  ConnectWallet,
  metamaskWallet,
  embeddedWallet,
} from "@thirdweb-dev/react";

const smartWalletOptions = {
  factoryAddress: "YOUR_FACTORY_ADDRESS",
  gasless: true,
};

export default function App() {
  return (
    <ThirdwebProvider
      activeChain="mumbai"
      clientId="YOUR_CLIENT_ID"
      supportedWallets={[
        smartWallet(
          metamaskWallet({ recommended: true }),
          smartWalletOptions,
        ),
        smartWallet(
          embeddedWallet(),
          smartWalletOptions,
        ),
      ]}
    >
      <ConnectWallet
        theme={"dark"}
        modalSize={"compact"}
      />
    </ThirdwebProvider>
  );
}

Sample code

Use the generated code as an implementation reference.

Steps

Create a project with Next.js + Typescript
Install SDK yarn add @thirdweb-dev/react @thirdweb-dev/sdk ethers@^5
Write the API Key and Account Factory address you created in env.local
Edit _app.tsx
Edit index.tx

Thirdweb Version
"@thirdweb-dev/react": "^3.16.2"
"@thirdweb-dev/sdk": "^3.10.64"

_app.tsx

import "@/styles/globals.css";
import type { AppProps } from "next/app";
import {
  ThirdwebProvider,
  smartWallet,
  metamaskWallet,
  embeddedWallet,
} from "@thirdweb-dev/react";

const activeChain = "mumbai";
const smartWalletOptions = {
  factoryAddress: process.env.NEXT_PUBLIC_FACTORY_ADDRESS || "",
  gasless: true,
};

function MyApp({ Component, pageProps }: AppProps) {
  return (
    <ThirdwebProvider
      activeChain={activeChain}
      clientId={process.env.NEXT_PUBLIC_TW_CLIENT_ID}
      supportedWallets={[
        smartWallet(metamaskWallet({ recommended: true }), smartWalletOptions),
        smartWallet(embeddedWallet(), smartWalletOptions),
      ]}
    >
      <Component {...pageProps} />
    </ThirdwebProvider>
  );
}

export default MyApp;

index.tsx

import { ConnectWallet } from "@thirdweb-dev/react";
import type { NextPage } from "next";

const Home: NextPage = () => {
  return (
    <main className="flex flex-col items-center justify-center p-10">
      <div className="">
        <ConnectWallet
          theme={"dark"}
          modalSize={"compact"}
          btnTitle={"Connect Wallet"}
          modalTitleIconUrl={""}
        />
      </div>
    </main>
  );
};

export default Home;

Operation check

Start with yarn dev
Confirm the activated URL (e.g., localhost:3000) with a PC browser.

Try to authenticate with your Gmail login.
If you enter your email address, an authentication code will be sent to you.

Address generated.
The smart wallet address will appear first.

In this case, two addresses are generated: Smart Wallet and Personal Wallet (Embedded Wallet).

Smart Wallet address
This time, the smart wallet address is gasless.
When you click on Connectted to Smart Wallet, you will see your Account details on the Thirdweb page. You can also check the NFTs you hold.

Personal Wallet (Embedded Wallet) Address
Wallet Users can be found on the Thirdweb dashboard under Embedded Wallets in the Wallets section.

Conclusion

I experimented with everything from setup to implementation and got the impression that it was very easy.
Thirdweb has an easy to use dashboard and is evolving more and more!

I did not put it here, but I tested a MATIC full amount transfer with a Smart Wallet address, and it worked without insufficient funds; with a Personal Wallet (Embedded Wallet) address, I got an insufficient funds error.

I also attempted a Claim at NFT (free price) on EditionDrop with a smart wallet address with zero balance, but it was successfully processed as gasless.
(I did not, however, see where they were processing the gasless.)

They also accept credit card payments, so I will try that next time I have the opportunity.

Implement Vercel AI SDK and LangChain JS with Next.js

Izawa — Sun, 01 Oct 2023 10:39:31 +0000

Introduction

Try to implement a chat page using ChatGPT's API.
I will use Vercel AI SDK, but I also tried LangChain with it.

Prerequisites

Experience with Next.js development

Advance preparation

Create an API key from OpenAI platform.

https://platform.openai.com/

Sample code

Steps

Create a Next.js + Typescript
Write OPENAI_API_KEY in env.local
Create /api/aiSdkChat.ts and /api/langChainChat.ts and edit index.tsx

Create a Next.js + Typescript

yarn create next-app sample-ai --typescript
cd sample-ai
yarn add ai openai-edge
yarn add langchain

Implementing SDKs

/api/aiSdkChat.ts

import { OpenAIStream, StreamingTextResponse } from "ai";
import { Configuration, OpenAIApi } from "openai-edge";
import { NextRequest } from "next/server";

export const runtime = "edge";

const config = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});
const openai = new OpenAIApi(config);

export default async function handler(req: NextRequest) {
  const { messages } = await req.json();

  const response = await openai.createChatCompletion({
    model: "gpt-3.5-turbo",
    stream: true,
    temperature: 0.9,
    messages: messages.map((message: any) => ({
      content: message.content,
      role: message.role,
    })),
  });
  const stream = OpenAIStream(response);
  return new StreamingTextResponse(stream);
}

/api/langChainChat.ts

import { StreamingTextResponse, LangChainStream, Message } from "ai";
import { ChatOpenAI } from "langchain/chat_models/openai";
import { AIMessage, HumanMessage } from "langchain/schema";
import { NextRequest } from "next/server";

export const runtime = "edge";

export default async function handler(req: NextRequest) {
  const { messages } = await req.json();
  const { stream, handlers } = LangChainStream();

  const llm = new ChatOpenAI({
    modelName: "gpt-3.5-turbo",
    streaming: true,
    temperature: 0.9,
  });

  llm
    .call(
      (messages as Message[]).map((m) =>
        m.role == "user"
          ? new HumanMessage(m.content)
          : new AIMessage(m.content)
      ),
      {},
      [handlers]
    )
    .catch(console.error);
  return new StreamingTextResponse(stream);
}

index.tsx
In useChat, specify either Vercel AI SDK or LangChain.

import type { NextPage } from "next";
import { useChat } from "ai/react";

const Home: NextPage = () => {
  const aiSdkChat = `/api/aiSdkChat`;
  const langChainChat = `/api/langChainChat`;

  const { messages, input, isLoading, stop, handleInputChange, handleSubmit } =
    useChat({
      api: aiSdkChat,
    });

  if (!isLoading) console.log(messages);

  return (
    <>
      <div className="mx-auto w-full max-w-md py-24 flex flex-col">
        <p className="font-bold text-lg">ChatGPT</p>
        <br />
        {messages.map((m) => (
          <div key={m.id} className="w-96 mb-2 p-2">
            {m.role === "user" ? "Human: " : "AI: "}
            {m.content}
          </div>
        ))}

        <br />
        <form onSubmit={handleSubmit}>
          <input
            name="box"
            className="w-96 flex rounded bottom-0 border border-gray-300 text-gray-700 mb-2 p-2"
            value={input}
            onChange={handleInputChange}
          />
          {isLoading ? (
            <button
              type="submit"
              className="opacity-50 cursor-not-allowed w-96 rounded bg-sky-500 hover:bg-sky-700 mb-2 p-2"
              disabled
            >
              Send
            </button>
          ) : (
            <button
              type="submit"
              className="w-96 rounded bg-sky-500 hover:bg-sky-700 mb-2 p-2"
            >
              Send
            </button>
          )}
        </form>
        <p className="w-96 text-slate-500 text-xs">
          You can check the value of a message variable from the console of the
          development tool to see how the value is stored.
        </p>
      </div>
    </>
  );
};

export default Home;

Start with yarn dev.
Try to display localhost:3000 in a PC browser.

Conversation with AI.

It appears to be working properly.

Conclusion

Thanks to the Vercel AI SDK, it was very easy to implement such a simple chat page.
Adding further error handling would provide an opportunity for better understanding.

LangChain has many interesting features such as AI Argent, which I will try again in the future.

Reference site
https://sdk.vercel.ai/docs/api-reference/use-chat
https://sdk.vercel.ai/docs/api-reference/langchain-stream
https://js.langchain.com/docs/get_started

Deploying FastAPI app with Google Cloud Run

Izawa — Tue, 27 Jun 2023 07:13:22 +0000

Introduction

This post explains how to deploy a FastAPI app using Google Cloud Run.

Prerequisites

Google Cloud account
gcloud CLI
Docker
Python

Project setup

Create a FastAPI app using Poetry.

pip install poetry
poetry new sample
cd sample
mv sample app
cd app
poetry add fastapi
poetry add 'uvicorn[standard]'

Create app/main.py

touch app/main.py

Edit main.py as follows

# main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/", tags=["root"])
async def root():
    return {"message": "Hello World"}

Run it in uvicorn

poetry shell
uvicorn app.main:app --reload

Google Cloud Run setup

If you have already installed gcloud CLI, update it as follows.

gcloud components update

Connect the gcloud CLI to your GCP account.

gcloud auth login

Set up your project ID

gcloud config set project PROJECT_ID

Region settings

gcloud config set run/region REGION

Docker settings

gcloud auth configure-docker

Prepare Dockerfile in the same hierarchy as the app directory.

FROM python:3.11.3
ENV PYTHONUNBUFFERED True

RUN pip install --upgrade pip
COPY requirements.txt .
RUN pip install --no-cache-dir -r  requirements.txt

ENV APP_HOME /root
WORKDIR $APP_HOME
COPY /app $APP_HOME/app

EXPOSE 8080
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]

Prepare requirements.txt file for Dockerfile.
(In this case, use requirements.txt in the Dockerfile.)

poetry export -f requirements.txt --output requirements.txt

Now that it is ready, deploy to Cloud Run.

gcloud run deploy sample --port 8080 --source .

If successful, it will be created with the name sample.
A URL will be created, so check the operation.

Conclusion

With the above, you can now deploy your FastAPI app to Google Cloud Run.

Although the details are omitted here, it would be a good idea to actually add CORS and headers in middleware and implement an authentication function such as Firebase Authentication.

Note: The path to import must be specified from the app directory.

Example: app/lib/test.py

# app/main.py
from app.lib import test

How to deploy FastAPI app using AWS CDK Typescript

Izawa — Wed, 14 Jun 2023 06:13:20 +0000

Introduction

In this post, I will explain how to deploy FastAPI to a Lambda function, using the Typescript-based AWS CDK.

Prerequisite

This article is intended for those who have experience building Lambda functions and API Gateways with Typescript-based AWS CDK.

Setup of AWS CDK and AWS CLI is omitted.
Python setup is omitted.
FastAPI description is omitted.

Development Environment

node v18.5.0
CDK 2.83.1
Python 3.11.3

Install the following

pip install fastapi
pip install mangum
pip install uvicorn

Create the app

mkdir sample-ts-fastapi
cd sample-ts-fastapi
cdk init --language typescript
npm install @aws-cdk/aws-lambda-python-alpha

Reference
@aws-cdk/aws-lambda-python-alpha

Defining Lambda and API Gateway

Modify lib/sample-ts-fastapi-stack.tsas follows.

import * as cdk from "aws-cdk-lib";
import { Construct } from "constructs";

import { PythonFunction } from "@aws-cdk/aws-lambda-python-alpha";
import { Runtime } from "aws-cdk-lib/aws-lambda";
import { LambdaRestApi } from "aws-cdk-lib/aws-apigateway";

export class SampleTsPyFastapiStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const apiName = `SampleApi`;
    const lambdaName = `MyLambda`;

    const lambda = new PythonFunction(this, lambdaName, {
      entry: "lambda",
      runtime: Runtime.PYTHON_3_10,
      index: "main.py",
      handler: "handler",
      environment: {},
    });
    const api = new LambdaRestApi(this, apiName, {
      handler: lambda,
    });
  }
}

Create Lambda Function

The directory and file structure should be as follows.
Create main.py and user.py.

lambda/
 ├ main.py
 ├ router/
   └ user.py

main.py

from fastapi import FastAPI
from mangum import Mangum
from .routers import user

app = FastAPI()


@app.get("/", tags=["root"])
async def root():
    return {"message": "Hello World"}

app.include_router(user.router)

handler = Mangum(app, lifespan="off")

user.py

from fastapi import APIRouter


router = APIRouter()

@router.get("/user", tags=["user"])
async def getUser():
    return {"message": "test user"}

Let’s try to run it in this state.

uvicorn lambda.main:app --reload

The API created on this page is now displayed. http://127.0.0.1:8000/docs

Deploy

Modify from routers import user in main.py. (It did not pass at .routers.)
Launch Docker in advance

cdk deploy

Adding the lambda layer

Since we are using FastAPI and Mangum, we create and add two layer.
There is also a way to include the Lambda Layer with the CDK and deploy it, but this time we did it by creating it separately.

Create s3 bucket
Zip the Python library
Upload zip to s3
Copy its Object URL
Create layers from the lambda page (Object URL is required)
Once the layer is created, copy its ARN

For 2 and 3, for example, create it this way.

pip install -t python/ fastapi
zip -r layer1.zip python
aws s3 cp layer1.zip s3://{backet name}/layer1.zip

Now that we have created two layers, FastAPI and Mangum, we can add them to the lambda function described earlier.

From the Lambda page of the AWS console, go to the function details page and add two layers. Enter the ARN from earlier here.

This completes the setup.

Conclusion

That’s it, I was able to get Python’s FastAPI to work with Lambda on the Typescript-based AWS CDK.

However, I could not figure out why the import path in the main.py code would not pass in Lambda unless I did it this way.

I am a beginner in Python. If there is a way to write code that can be executed without worrying about the difference between the path environment on Lambda and the local path environment, I would appreciate it if someone could tell me.