Ver3.5 ๐ค ChatGPT + Jira ์ฐ๋์ผ๋ก ์์ฑํ๋AI ๊ธฐ๋ฐ ์๋ ์ด์ ๊ด๋ฆฌ ์์คํ ๊ตฌ์ถ ์์ ๊ฐ์ด๋

๐ค ChatGPT + Jira ์ฐ๋์ผ๋ก ์์ฑํ๋
AI ๊ธฐ๋ฐ ์๋ ์ด์ ๊ด๋ฆฌ ์์คํ
๊ตฌ์ถ ์์ ๊ฐ์ด๋
โจ ๋ฐ๋ณต ์ ๋ฌด๋ AIํํ ๋งก๊ธฐ๊ณ ๊ฐ๋ฐ์๋ ์ง์ง ๊ฐ๋ฐ๋ง ํ์ โจ
์ผ ์์งํ ๋งํด๋ดใ
ใ
ใ
๊ฐ๋ฐ์๋ก ์ผํ๋ค ๋ณด๋ฉด ์ง์ง ์ฝ๋ฉ๋ณด๋ค ์ด์ ๊ด๋ฆฌ์ ์ฐ๋ ์๊ฐ์ด ๋ ๋ง์ ๋ ์์ง ์์?
๊ณ ๊ฐํํ
๋ฒ๊ทธ ๋ฆฌํฌํธ ๋ค์ด์ค๋ฉด โ Jira ๋ค์ด๊ฐ์ โ ์ด์ ๋ง๋ค๊ณ โ ์ ๋ชฉ ์ฐ๊ณ โ ์ค๋ช
์ฐ๊ณ โ ์ฐ์ ์์ ์ ํ๊ณ โ ๋ด๋น์ ๋ฐฐ์ ํ๊ณ โ ์คํ๋ฆฐํธ์ ๋ฃ๊ณ ... ์ด ๋ฐ๋ณต ์์
์ด ํ๋ฃจ์ ๋ช ๋ฒ์ฉ ์ผ์ด๋๋ ๊ฑฐ ์์ง?
์ค์ ๋ก Atlassian์ด 2023๋
์ ๋ฐํํ ๋ฆฌํฌํธ์ ๋ฐ๋ฅด๋ฉด ๊ฐ๋ฐํ ๊ตฌ์ฑ์๋ค์ด ์ด์ ํธ๋ํน ๋ฐ ๊ด๋ฆฌ์ ์ฃผ๋น ํ๊ท 5~8์๊ฐ์ ์๋นํ๋ค๊ณ ํด. 1๋
์ผ๋ก ํ์ฐํ๋ฉด 260~416์๊ฐ... ์ด๊ฒ ๋ง์ด ๋จ?? ๐ฑ
๊ทผ๋ฐ ์ด๊ฑธ ChatGPT API + Jira REST API๋ก ์ฐ๋ํ๋ฉด? ๊ทธ ๋ฐ๋ณต ์์
์ 70~80%๋ฅผ ์๋ํํ ์ ์์ด. ์ค๋์ ์ด ์์คํ
์ ์ด๋ป๊ฒ ๊ตฌ์ถํ๋์ง ์ง์ง ์ค์ ๋ ๋ฒจ๋ก ํํค์ณ๋ณผ๊ฒ.
๋จผ์ ์ด ์กฐํฉ์ด ์ ๊ฐ๋ ฅํ์ง ์ดํดํด์ผ ํด. ๊ฐ๊ฐ์ ์ญํ ์ด ์์ ํ ๋ค๋ฅด๊ฑฐ๋ .
์์ฐ์ด๋ฅผ ์ดํดํ๊ณ ๊ตฌ์กฐํ๋ ๋ฐ์ดํฐ๋ก ๋ณํํ๋ ๊ฒ ํต์ฌ์ด์ผ.
"๋ก๊ทธ์ธ ๋ฒํผ ํด๋ฆญํ๋ฉด ์ฑ์ด ํ๊ฒจ์ ใ ใ " ๊ฐ์ ๋น์ ํ ํ ์คํธ๋ฅผ
โ ์ด์ ํ์ : Bug
โ ์ฌ๊ฐ๋: High
โ ์ปดํฌ๋ํธ: Auth
์ด๋ฐ ๊ตฌ์กฐํ๋ ๋ฐ์ดํฐ๋ก ๋ฐ๊ฟ์ค
๊ตฌ์กฐํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์ ์ค์ ์ด์๋ก ๋ง๋ค๊ณ ํ๋ก์ ํธ ๊ด๋ฆฌ๋ฅผ ํด์ฃผ๋ ๊ฑฐ์ผ.
REST API๋ฅผ ํตํด ์ธ๋ถ์์ ์ด์ ์์ฑ, ์์ , ์กฐํ, ์ญ์ ๊ฐ ์ ๋ถ ๊ฐ๋ฅํ๊ณ
Webhook์ผ๋ก ์ด๋ฒคํธ ๊ธฐ๋ฐ ์๋ํ๋ ์ง์ํจ
์ด ๋ ๊ฐ๋ฅผ ์ฐ๊ฒฐํ๋ ๋ฏธ๋ค์จ์ด(Python ๋๋ Node.js)๊ฐ ์ค๊ฐ์์ ๋ฐ์ดํฐ๋ฅผ ๋ณํํ๊ณ ๋ผ์ฐํ ํด์ฃผ๋ ๊ตฌ์กฐ์ผ. ์์ ์ฌํํ์ง๋ง ํ์ํํจ ใ ใ
์ฝ๋ ์ง๊ธฐ ์ ์ ์ค๋นํด์ผ ํ ๊ฒ๋ค ๋จผ์ ์ ๋ฆฌํด๋ณผ๊ฒ. ์ด๊ฑฐ ๋น ๋จ๋ฆฌ๋ฉด ๋์ค์ ์ฝ์งํจ ใ ใ ใ
GPT-4o GPT-4-turbo GPT-3.5-turbo (์ ๋น์ฉ)
๐ฐ ๋น์ฉ ์ฐธ๊ณ : GPT-4o ๊ธฐ์ค input $2.50/1M tokens, output $10.00/1M tokens (2024๋ ๊ธฐ์ค)
Jira Cloud ๊ธฐ์ค์ด๊ณ , Jira Server/Data Center๋ Personal Access Token ๋ฐฉ์์ด ๋ค๋ฆ.
ํ์ํ ์ ๋ณด: Jira URL ์ด๋ฉ์ผ API Token Project Key
openai โ OpenAI ๊ณต์ Python ํด๋ผ์ด์ธํธrequests โ Jira REST API ํธ์ถ์ฉpython-dotenv โ ํ๊ฒฝ๋ณ์ ๊ด๋ฆฌfastapi โ ์นํ
์๋ฒ ๊ตฌ์ถ ์ (์ ํ)pydantic โ ๋ฐ์ดํฐ ๊ฒ์ฆ
# ํจํค์ง ์ค์น
pip install openai requests python-dotenv fastapi uvicorn pydantic
# .env ํ์ผ ๊ตฌ์ฑ
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxx
JIRA_URL=https://yourcompany.atlassian.net
JIRA_EMAIL=your@email.com
JIRA_API_TOKEN=xxxxxxxxxxxxxxxx
JIRA_PROJECT_KEY=DEV
์ด์ ์ง์ง ์ฝ๋ ์ง๋ณผ ์๊ฐ์ด์ผ. ๋จผ์ ChatGPT API๋ฅผ ํ์ฉํด์ ์์ฐ์ด ํ ์คํธ๋ฅผ Jira ์ด์ ๊ตฌ์กฐ๋ก ๋ณํํ๋ ๋ถ๋ถ๋ถํฐ ์์ํด๋ณด์.
ํต์ฌ์ System Prompt ์ค๊ณ์ผ. GPTํํ ์ด๋ค ์ญํ ์ ์ค์ง, ์ด๋ค ํ์์ผ๋ก ์ถ๋ ฅํ ์ง๋ฅผ ๋ช ํํ๊ฒ ์ง์ ํด์ค์ผ ํด.
import openai
import json
import os
from dotenv import load_dotenv
load_dotenv()
client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def analyze_issue_with_gpt(raw_text: str, project_components: list = None) -> dict:
"""
์์ฐ์ด ํ
์คํธ๋ฅผ Jira ์ด์ ๊ตฌ์กฐ๋ก ๋ณํ
"""
components_info = ""
if project_components:
components_info = f"\n์ฌ์ฉ ๊ฐ๋ฅํ ์ปดํฌ๋ํธ: {', '.join(project_components)}"
system_prompt = f"""๋น์ ์ ์ํํธ์จ์ด ๊ฐ๋ฐํ์ ์ด์ ๊ด๋ฆฌ ์ ๋ฌธ๊ฐ์
๋๋ค.
์
๋ ฅ๋ ํ
์คํธ๋ฅผ ๋ถ์ํ์ฌ Jira ์ด์ ์์ฑ์ ํ์ํ ์ ๋ณด๋ฅผ JSON ํ์์ผ๋ก ์ถ์ถํ์ธ์.
{components_info}
๋ฐ๋์ ๋ค์ JSON ํ์์ผ๋ก๋ง ์๋ตํ์ธ์:
{{
"summary": "์ด์ ์ ๋ชฉ (50์ ์ด๋ด, ๋ช
ํํ๊ณ ๊ฐ๊ฒฐํ๊ฒ)",
"description": "์์ธ ์ค๋ช
(์ฌํ ๋ฐฉ๋ฒ, ํ๊ฒฝ, ๊ธฐ๋ ๋์, ์ค์ ๋์ ํฌํจ)",
"issuetype": "Bug|Task|Story|Epic ์ค ํ๋",
"priority": "Critical|High|Medium|Low ์ค ํ๋",
"component": "ํด๋น ์ปดํฌ๋ํธ๋ช
๋๋ null",
"labels": ["๊ด๋ จ ๋ ์ด๋ธ ๋ฐฐ์ด"],
"story_points": 1~13 ์ฌ์ด ์ซ์ ๋๋ null,
"suggested_assignee_role": "๋ด๋น์ ์ญํ (์: iOS๊ฐ๋ฐ์, ๋ฐฑ์๋๊ฐ๋ฐ์, ๋์์ด๋)",
"confidence_score": 0.0~1.0 ์ฌ์ด ๋ถ์ ์ ๋ขฐ๋
}}
์ฐ์ ์์ ํ๋จ ๊ธฐ์ค:
- Critical: ์๋น์ค ์ ์ฒด ์ฅ์ , ๊ฒฐ์ ์ค๋ฅ, ๋ณด์ ์ทจ์ฝ์
- High: ์ฃผ์ ๊ธฐ๋ฅ ์ค์๋, ๋ค์ ์ฌ์ฉ์ ์ํฅ
- Medium: ์ผ๋ถ ๊ธฐ๋ฅ ์ค๋ฅ, ์์ ์ฌ์ฉ์ ์ํฅ
- Low: UI ๊ฐ์ , ์ฌ์ํ ๋ฒ๊ทธ"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": f"๋ค์ ํ
์คํธ๋ฅผ ๋ถ์ํด์ฃผ์ธ์:\n\n{raw_text}"}
],
response_format={"type": "json_object"}, # JSON ๋ชจ๋ ํ์ฑํ
temperature=0.3 # ์ผ๊ด์ฑ์ ์ํด ๋ฎ์ temperature
)
result = json.loads(response.choices[0].message.content)
return result
์ด์ ๋ถ์๋ ๋ฐ์ดํฐ๋ฅผ ์ค์ Jira์ ์ด์๋ก ๋ง๋๋ ์ฝ๋์ผ. Jira REST API v3 ๊ธฐ์ค์ด์ผ.
import requests
from requests.auth import HTTPBasicAuth
import os
class JiraClient:
def __init__(self):
self.base_url = os.getenv("JIRA_URL")
self.auth = HTTPBasicAuth(
os.getenv("JIRA_EMAIL"),
os.getenv("JIRA_API_TOKEN")
)
self.headers = {
"Accept": "application/json",
"Content-Type": "application/json"
}
self.project_key = os.getenv("JIRA_PROJECT_KEY")
def create_issue(self, issue_data: dict) -> dict:
"""
Jira ์ด์ ์์ฑ
"""
# Jira API ํ์์ผ๋ก ๋ฐ์ดํฐ ๋ณํ
payload = {
"fields": {
"project": {"key": self.project_key},
"summary": issue_data["summary"],
"description": {
"type": "doc",
"version": 1,
"content": [
{
"type": "paragraph",
"content": [
{"type": "text", "text": issue_data["description"]}
]
}
]
},
"issuetype": {"name": issue_data["issuetype"]},
"priority": {"name": issue_data["priority"]},
"labels": issue_data.get("labels", [])
}
}
# ์ปดํฌ๋ํธ๊ฐ ์์ ๊ฒฝ์ฐ ์ถ๊ฐ
if issue_data.get("component"):
payload["fields"]["components"] = [
{"name": issue_data["component"]}
]
# Story Points ์ถ๊ฐ (์ปค์คํ
ํ๋ ID๋ ํ๋ก์ ํธ๋ง๋ค ๋ค๋ฆ)
if issue_data.get("story_points"):
payload["fields"]["story_points"] = issue_data["story_points"]
url = f"{self.base_url}/rest/api/3/issue"
response = requests.post(
url,
json=payload,
headers=self.headers,
auth=self.auth
)
if response.status_code == 201:
return response.json()
else:
raise Exception(f"Jira ์ด์ ์์ฑ ์คํจ: {response.status_code} - {response.text}")
def get_project_components(self) -> list:
"""
ํ๋ก์ ํธ ์ปดํฌ๋ํธ ๋ชฉ๋ก ์กฐํ
"""
url = f"{self.base_url}/rest/api/3/project/{self.project_key}/components"
response = requests.get(url, headers=self.headers, auth=self.auth)
if response.status_code == 200:
return [comp["name"] for comp in response.json()]
return []
def search_similar_issues(self, summary: str, max_results: int = 5) -> list:
"""
์ ์ฌ ์ด์ ๊ฒ์ (์ค๋ณต ๋ฐฉ์ง์ฉ)
"""
# JQL๋ก ์ ์ฌ ์ด์ ๊ฒ์
jql = f'project = {self.project_key} AND summary ~ "{summary[:30]}" ORDER BY created DESC'
url = f"{self.base_url}/rest/api/3/search"
params = {"jql": jql, "maxResults": max_results}
response = requests.get(
url, params=params, headers=self.headers, auth=self.auth
)
if response.status_code == 200:
return response.json().get("issues", [])
return []
์ด์ ๋ ๋ชจ๋์ ์ฐ๊ฒฐํด์ ์ค์ ๋ก ๋์ํ๋ ํ์ดํ๋ผ์ธ์ ๋ง๋ค์ด๋ณด์.
def auto_create_jira_issue(raw_text: str) -> dict:
"""
์์ฐ์ด ํ
์คํธ โ Jira ์ด์ ์๋ ์์ฑ ๋ฉ์ธ ํ์ดํ๋ผ์ธ
"""
jira = JiraClient()
# 1. ํ๋ก์ ํธ ์ปดํฌ๋ํธ ์กฐํ (GPT ๋ถ์์ ํ์ฉ)
components = jira.get_project_components()
print(f"๐ ํ๋ก์ ํธ ์ปดํฌ๋ํธ: {components}")
# 2. ChatGPT๋ก ์ด์ ๋ถ์
print("๐ค ChatGPT ๋ถ์ ์ค...")
analyzed = analyze_issue_with_gpt(raw_text, components)
print(f"โ
๋ถ์ ์๋ฃ (์ ๋ขฐ๋: {analyzed.get('confidence_score', 0):.0%})")
print(f" - ์ ๋ชฉ: {analyzed['summary']}")
print(f" - ํ์
: {analyzed['issuetype']} / ์ฐ์ ์์: {analyzed['priority']}")
# 3. ์ค๋ณต ์ด์ ์ฒดํฌ
similar_issues = jira.search_similar_issues(analyzed['summary'])
if similar_issues:
print(f"โ ๏ธ ์ ์ฌ ์ด์ {len(similar_issues)}๊ฐ ๋ฐ๊ฒฌ:")
for issue in similar_issues:
print(f" - {issue['key']}: {issue['fields']['summary']}")
# ์ ๋ขฐ๋๊ฐ ๋ฎ๊ฑฐ๋ ์ ์ฌ ์ด์๊ฐ ๋ง์ผ๋ฉด ์์ฑ ๋ณด๋ฅ
if analyzed.get('confidence_score', 1) < 0.7:
return {"status": "review_needed", "analyzed": analyzed, "similar": similar_issues}
# 4. Jira ์ด์ ์์ฑ
print("๐ Jira ์ด์ ์์ฑ ์ค...")
created_issue = jira.create_issue(analyzed)
issue_key = created_issue["key"]
issue_url = f"{os.getenv('JIRA_URL')}/browse/{issue_key}"
print(f"๐ ์ด์ ์์ฑ ์๋ฃ!")
print(f" URL: {issue_url}")
return {
"status": "created",
"issue_key": issue_key,
"issue_url": issue_url,
"analyzed_data": analyzed
}
# ์คํ ์์
if __name__ == "__main__":
test_text = """
์๋
ํ์ธ์, ๊ฒฐ์ ์๋ฃ ํ ์ฑ์ด ๊ฐ์๊ธฐ ๊บผ์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๊ณ ์์ด์.
iPhone 15 Pro, iOS 17.2 ํ๊ฒฝ์์ ์ฌํ๋ฉ๋๋ค.
์นด๋ ๊ฒฐ์ ์๋ฃ ๋ฒํผ ํด๋ฆญ ํ 100% ์ฌํ๋๊ณ ,
๊ฒฐ์ ๋ ์ค์ ๋ก ์๋ฃ๋์ง๋ง ์ฑ์ด ์ข
๋ฃ๋์ด ์์์ฆ ํ์ธ์ด ๋ถ๊ฐํฉ๋๋ค.
"""
result = auto_create_jira_issue(test_text)
print(f"\n๊ฒฐ๊ณผ: {result}")
์ ์ฝ๋๋ฅผ ๊ทธ๋ฅ ์คํฌ๋ฆฝํธ๋ก๋ง ์ฐ๋ฉด ๋ฐ์ชฝ์ง๋ฆฌ์ผ. ์ง์ง ์๋ํ๋ ์นํ
(Webhook)์ผ๋ก ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ ๋๋ง๋ค ์๋์ผ๋ก ์คํ๋๊ฒ ํด์ผ ํด.
FastAPI๋ก ์นํ
์๋ฒ๋ฅผ ๋ง๋ค์ด์ ์ฌ๋, ์ด๋ฉ์ผ, ๋ชจ๋ํฐ๋ง ๋๊ตฌ ๋ฑ์์ ์ด๋ฒคํธ๊ฐ ์ค๋ฉด ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค์ด๋ณด์.
from fastapi import FastAPI, HTTPException, BackgroundTasks
from pydantic import BaseModel
from typing import Optional
import hmac
import hashlib
app = FastAPI(title="ChatGPT-Jira ์๋ํ ์๋ฒ")
# ์์ฒญ ๋ชจ๋ธ ์ ์
class IssueRequest(BaseModel):
text: str
source: Optional[str] = "manual" # slack, email, sentry, manual
reporter: Optional[str] = None
metadata: Optional[dict] = {}
class SlackWebhookPayload(BaseModel):
text: Optional[str] = None
event: Optional[dict] = None
# ๋ฉ์ธ ์ด์ ์์ฑ ์๋ํฌ์ธํธ
@app.post("/api/create-issue")
async def create_issue_endpoint(
request: IssueRequest,
background_tasks: BackgroundTasks
):
"""
ํ
์คํธ๋ฅผ ๋ฐ์ Jira ์ด์ ์๋ ์์ฑ
"""
if not request.text.strip():
raise HTTPException(status_code=400, detail="ํ
์คํธ๊ฐ ๋น์ด์์ต๋๋ค")
# ๋ฐฑ๊ทธ๋ผ์ด๋์์ ์ฒ๋ฆฌ (์๋ต ์ง์ฐ ๋ฐฉ์ง)
background_tasks.add_task(
auto_create_jira_issue,
request.text
)
return {
"status": "processing",
"message": "์ด์ ์์ฑ ์์ฒญ์ด ์ ์๋์์ต๋๋ค. ์ ์ ํ Jira์์ ํ์ธํ์ธ์."
}
# Sentry ์นํ
์ฒ๋ฆฌ
@app.post("/webhook/sentry")
async def sentry_webhook(payload: dict):
"""
Sentry ์๋ฌ ์๋ฆผ โ Jira ์ด์ ์๋ ์์ฑ
"""
if payload.get("action") == "created":
issue = payload.get("data", {}).get("issue", {})
error_text = f"""
[Sentry ์๋ ๊ฐ์ง ์๋ฌ]
์๋ฌ๋ช
: {issue.get('title', 'Unknown Error')}
๋ฐ์ ํ์: {issue.get('count', 0)}ํ
์ํฅ ์ฌ์ฉ์: {issue.get('userCount', 0)}๋ช
์ฒซ ๋ฐ์: {issue.get('firstSeen', '')}
๋ง์ง๋ง ๋ฐ์: {issue.get('lastSeen', '')}
URL: {issue.get('permalink', '')}
"""
result = auto_create_jira_issue(error_text)
return {"status": "ok", "jira_issue": result.get("issue_key")}
return {"status": "ignored"}
# ์ฌ๋ ์ฌ๋์ ์ปค๋งจ๋ ์ฒ๋ฆฌ
@app.post("/webhook/slack")
async def slack_webhook(payload: dict):
"""
์ฌ๋ /jira-issue ์ปค๋งจ๋ ์ฒ๋ฆฌ
"""
text = payload.get("text", "")
user_name = payload.get("user_name", "Unknown")
if not text:
return {"text": "โ ์ด์ ๋ด์ฉ์ ์
๋ ฅํด์ฃผ์ธ์. ์: /jira-issue ๋ก๊ทธ์ธ ๋ฒํผ ํด๋ฆญ ์ ์ฑ ์ข
๋ฃ"}
result = auto_create_jira_issue(text)
if result["status"] == "created":
return {
"text": f"โ
Jira ์ด์๊ฐ ์์ฑ๋์์ต๋๋ค!\n"
f"์ด์ ํค: *{result['issue_key']}*\n"
f"๋งํฌ: {result['issue_url']}\n"
f"์์ฒญ์: {user_name}"
}
else:
return {"text": "โ ๏ธ ์ ์ฌ ์ด์๊ฐ ๋ฐ๊ฒฌ๋์ด ๊ฒํ ๊ฐ ํ์ํฉ๋๋ค."}
# ์๋ฒ ์คํ
# uvicorn main:app --host 0.0.0.0 --port 8000 --reload
๋จ์ํ ์ด์ ๋ง๋๋ ๊ฒ์์ ํ ๋ฐ ๋ ๋์๊ฐ์, ๋ด๋น์๊น์ง ์๋์ผ๋ก ๋ฐฐ์ ํ๋ ์์คํ ์ ๋ง๋ค์ด๋ณด์. ์ด๊ฒ ์ง์ง ๊ฟ๊ธฐ๋ฅ์ ใ ใ ใ
GPT๊ฐ ๋ถ์ํ ์ปดํฌ๋ํธ, ์ด์ ํ์ , ๊ธฐ์ ์คํ ์ ๋ณด๋ฅผ ๋ฐํ์ผ๋ก ์ ์ ํ ๋ด๋น์๋ฅผ ์๋์ผ๋ก ๋ฐฐ์ ํ๋ ๋ก์ง์ด์ผ.
# ํ ๊ตฌ์ฑ ์ค์ (์ค์ ๋ก๋ DB๋ ์ค์ ํ์ผ๋ก ๊ด๋ฆฌ)
TEAM_CONFIG = {
"components": {
"Auth": {
"team": "๋ฐฑ์๋ํ",
"members": ["user_id_1", "user_id_2"],
"primary": "user_id_1"
},
"iOS": {
"team": "๋ชจ๋ฐ์ผํ",
"members": ["user_id_3", "user_id_4"],
"primary": "user_id_3"
},
"Payment": {
"team": "๊ฒฐ์ ํ",
"members": ["user_id_5"],
"primary": "user_id_5"
},
"UI/UX": {
"team": "๋์์ธํ",
"members": ["user_id_6", "user_id_7"],
"primary": "user_id_6"
}
},
"issue_types": {
"Bug": "primary", # ๋ฒ๊ทธ๋ ์ฃผ๋ด๋น์์๊ฒ
"Task": "round_robin", # ํ์คํฌ๋ ์ํ ๋ฐฐ์
"Story": "primary"
}
}
def get_assignee(component: str, issue_type: str, jira_client: JiraClient) -> str:
"""
์ปดํฌ๋ํธ์ ์ด์ ํ์
๊ธฐ๋ฐ ๋ด๋น์ ์๋ ๊ฒฐ์
"""
if not component or component not in TEAM_CONFIG["components"]:
return None
comp_config = TEAM_CONFIG["components"][component]
assignment_rule = TEAM_CONFIG["issue_types"].get(issue_type, "primary")
if assignment_rule == "primary":
return comp_config["primary"]
elif assignment_rule == "round_robin":
# ํ์ฌ ๊ฐ ๋ฉค๋ฒ์ ๋ฏธ์๋ฃ ์ด์ ์๋ฅผ ์กฐํํด์ ๊ฐ์ฅ ์ ์ ์ฌ๋์๊ฒ ๋ฐฐ์
min_issues = float('inf')
selected_member = comp_config["primary"]
for member_id in comp_config["members"]:
# JQL๋ก ํด๋น ๋ฉค๋ฒ์ ๋ฏธ์๋ฃ ์ด์ ์ ์กฐํ
jql = f'assignee = {member_id} AND status != Done AND project = {jira_client.project_key}'
url = f"{jira_client.base_url}/rest/api/3/search"
response = requests.get(
url,
params={"jql": jql, "maxResults": 0},
headers=jira_client.headers,
auth=jira_client.auth
)
if response.status_code == 200:
total = response.json().get("total", 0)
if total < min_issues:
min_issues = total
selected_member = member_id
return selected_member
return comp_config["primary"]
Critical/High ์ฐ์ ์์ ์ด์๋ ํ์ฌ ์งํ ์ค์ธ ์คํ๋ฆฐํธ์ ์๋์ผ๋ก ๋ฃ๊ณ , Medium/Low๋ ๋ค์ ์คํ๋ฆฐํธ ๋ฐฑ๋ก๊ทธ์ ์ถ๊ฐํ๋ ๋ก์ง์ด์ผ.
def get_current_sprint_id(jira_client: JiraClient, board_id: int) -> Optional[int]:
"""
ํ์ฌ ํ์ฑ ์คํ๋ฆฐํธ ID ์กฐํ
"""
url = f"{jira_client.base_url}/rest/agile/1.0/board/{board_id}/sprint"
params = {"state": "active"}
response = requests.get(
url, params=params,
headers=jira_client.headers,
auth=jira_client.auth
)
if response.status_code == 200:
sprints = response.json().get("values", [])
if sprints:
return sprints[0]["id"]
return None
def assign_to_sprint(jira_client: JiraClient, issue_key: str, priority: str, board_id: int):
"""
์ฐ์ ์์์ ๋ฐ๋ผ ์คํ๋ฆฐํธ ์๋ ๋ฐฐ์
"""
if priority in ["Critical", "High"]:
sprint_id = get_current_sprint_id(jira_client, board_id)
if sprint_id:
url = f"{jira_client.base_url}/rest/agile/1.0/sprint/{sprint_id}/issue"
payload = {"issues": [issue_key]}
requests.post(
url, json=payload,
headers=jira_client.headers,
auth=jira_client.auth
)
print(f"๐ {issue_key}๋ฅผ ํ์ฌ ์คํ๋ฆฐํธ(ID: {sprint_id})์ ๋ฐฐ์ ")
else:
print(f"๐ {issue_key}๋ ๋ฐฑ๋ก๊ทธ์ ์ ์ง (์ฐ์ ์์: {priority})")
๋จ์ ํค์๋ ๊ฒ์์ผ๋ก๋ ์ค๋ณต ์ด์๋ฅผ ์๋ฒฝํ๊ฒ ์ก๊ธฐ ์ด๋ ค์. OpenAI Embeddings API๋ฅผ ํ์ฉํ๋ฉด ์๋ฏธ์ ์ผ๋ก ์ ์ฌํ ์ด์๋ฅผ ํจ์ฌ ์ ํํ๊ฒ ์ฐพ์ ์ ์์ด.
OpenAI์
text-embedding-3-small ๋ชจ๋ธ ๊ธฐ์ค์ผ๋ก 1536์ฐจ์ ๋ฒกํฐ๋ฅผ ์์ฑํ๊ณ , ์ฝ์ฌ์ธ ์ ์ฌ๋๋ก ๋น๊ตํจ.
import numpy as np
from typing import List, Tuple
def get_embedding(text: str) -> List[float]:
"""
ํ
์คํธ๋ฅผ ์๋ฒ ๋ฉ ๋ฒกํฐ๋ก ๋ณํ
"""
response = client.embeddings.create(
model="text-embedding-3-small",
input=text
)
return response.data[0].embedding
def cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
"""
์ฝ์ฌ์ธ ์ ์ฌ๋ ๊ณ์ฐ (1.0 = ์์ ๋์ผ, 0.0 = ์์ ๋ค๋ฆ)
"""
v1 = np.array(vec1)
v2 = np.array(vec2)
return float(np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)))
def find_duplicate_issues(
new_summary: str,
existing_issues: List[dict],
threshold: float = 0.85
) -> List[Tuple[dict, float]]:
"""
์ ์ด์์ ๊ธฐ์กด ์ด์๋ค์ ์ ์ฌ๋ ๋น๊ต
threshold: ์ด ๊ฐ ์ด์์ด๋ฉด ์ค๋ณต์ผ๋ก ํ๋จ (0.85 ๊ถ์ฅ)
"""
new_embedding = get_embedding(new_summary)
duplicates = []
for issue in existing_issues:
existing_summary = issue["fields"]["summary"]
existing_embedding = get_embedding(existing_summary)
similarity = cosine_similarity(new_embedding, existing_embedding)
if similarity >= threshold:
duplicates.append((issue, similarity))
print(f"๐ ์ ์ฌ ์ด์ ๋ฐ๊ฒฌ: {issue['key']} (์ ์ฌ๋: {similarity:.2%})")
print(f" ๊ธฐ์กด: {existing_summary}")
# ์ ์ฌ๋ ๋์ ์์ผ๋ก ์ ๋ ฌ
duplicates.sort(key=lambda x: x[1], reverse=True)
return duplicates
# ์ค์ ์ฌ์ฉ ์์
# ์ ์ด์: "๋ก๊ทธ์ธ ๋ฒํผ ํด๋ฆญ ์ ์ฑ ํฌ๋์"
# ๊ธฐ์กด ์ด์: "๋ก๊ทธ์ธ ํ๋ฉด์์ ์ฑ์ด ์ข
๋ฃ๋จ" โ ์ ์ฌ๋ 0.91 โ ์ค๋ณต!
# ๊ธฐ์กด ์ด์: "ํ์๊ฐ์
๋ฒํผ ์ค๋ฅ" โ ์ ์ฌ๋ 0.43 โ ๋ค๋ฅธ ์ด์
์ง๊ธ๊น์ง๋ ์ธ๋ถ โ ChatGPT โ Jira ๋ฐฉํฅ์ด์๋๋ฐ, ๋ฐ๋๋ก Jira์์ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ChatGPT๊ฐ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ ์ญ๋ฐฉํฅ ์๋ํ๋ ๊ฐ๋ฅํด.
๊ฐ๋ฐ์๊ฐ ๊ฐ๋จํ๊ฒ ์ด์๋ฅผ ๋ง๋ค๋ฉด GPT๊ฐ ์๋์ผ๋ก ์์ธ ์ค๋ช , ์ฌํ ๋ฐฉ๋ฒ, ์์ ์์ธ ๋ฑ์ ๋ณด์ํด์ค
์ด์ ๋ด์ฉ์ ๋ถ์ํด์ ๊ด๋ จ ๊ธฐ์ ์คํ, ์ํฅ ๋ฒ์, ๊ด๋ จ ๊ธฐ๋ฅ ๋ฑ์ ๋ ์ด๋ธ์ ์๋์ผ๋ก ์ถ๊ฐ
๋งค์ฃผ ์์์ผ ์์นจ์ ์ง๋ ์ฃผ ์ด์๋ค์ ๋ถ์ํด์ ํธ๋ ๋, ๋ฐ๋ณต ํจํด, ๊ฐ์ ์ ์์ ์ฌ๋์ผ๋ก ์ ์ก
์ ์ด์๊ฐ ์์ฑ๋ ๋ ๊ด๋ จ๋ ๊ธฐ์กด ์ด์๋ค์ ์๋์ผ๋ก ์ฐพ์์ ๋งํฌ ์ฐ๊ฒฐ
@app.post("/webhook/jira")
async def jira_webhook(payload: dict):
"""
Jira ์ด๋ฒคํธ โ ChatGPT ์๋ ์ฒ๋ฆฌ
"""
event_type = payload.get("webhookEvent")
issue = payload.get("issue", {})
issue_key = issue.get("key", "")
fields = issue.get("fields", {})
# ์ด์ ์์ฑ ์ ์ค๋ช
์๋ ๋ณด์
if event_type == "jira:issue_created":
summary = fields.get("summary", "")
description = fields.get("description", "")
# ์ค๋ช
์ด ๋๋ฌด ์งง์ผ๋ฉด GPT๋ก ๋ณด์
if len(str(description)) < 100:
enhanced_description = enhance_issue_description(summary, str(description))
# Jira ์ด์ ์
๋ฐ์ดํธ
jira = JiraClient()
update_url = f"{jira.base_url}/rest/api/3/issue/{issue_key}"
update_payload = {
"fields": {
"description": {
"type": "doc",
"version": 1,
"content": [{"type": "paragraph", "content": [
{"type": "text", "text": enhanced_description}
]}]
}
}
}
requests.put(
update_url, json=update_payload,
headers=jira.headers, auth=jira.auth
)
print(f"โ๏ธ {issue_key} ์ค๋ช
์๋ ๋ณด์ ์๋ฃ")
return {"status": "ok"}
def enhance_issue_description(summary: str, current_desc: str) -> str:
"""
GPT๋ก ์ด์ ์ค๋ช
์๋ ๋ณด์
"""
prompt = f"""๋ค์ Jira ์ด์์ ์ค๋ช
์ ๊ฐ๋ฐํ์ด ์ดํดํ๊ธฐ ์ฝ๋๋ก ๋ณด์ํด์ฃผ์ธ์.
์ด์ ์ ๋ชฉ: {summary}
ํ์ฌ ์ค๋ช
: {current_desc}
๋ค์ ํ์์ผ๋ก ์์ฑํด์ฃผ์ธ์:
## ๋ฌธ์ ์ค๋ช
(ํ์ฌ ์ค๋ช
๊ธฐ๋ฐ์ผ๋ก ์์ธํ)
## ์์ ์ฌํ ๋ฐฉ๋ฒ
(์ ๋ชฉ์์ ์ ์ถ ๊ฐ๋ฅํ ์ฌํ ๋ฐฉ๋ฒ)
## ํ์ธ์ด ํ์ํ ์ฌํญ
(๊ฐ๋ฐ์๊ฐ ์ถ๊ฐ๋ก ํ์ธํด์ผ ํ ์ ๋ณด๋ค)
## ๊ด๋ จ ๊ฐ๋ฅ์ฑ์ด ์๋ ์์ญ
(์ ๋ชฉ ๊ธฐ๋ฐ์ผ๋ก ์ํฅ๋ฐ์ ์ ์๋ ์ฝ๋ ์์ญ)"""
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": prompt}],
temperature=0.5
)
return response.choices[0].message.content
ChatGPT API๋ ์ฌ์ฉ๋์ ๋ฐ๋ผ ๋น์ฉ์ด ๋ฐ์ํ๋๊น ์ค๋งํธํ๊ฒ ์ฐ๋ ๋ฐฉ๋ฒ์ ์์์ผ ํด. ์๋ชปํ๋ฉด API ๋น์ฉ์ด ํญํ ๋ง์ ใ ใ ใ
๋จ์ ๋ถ๋ฅ ์์ ์
gpt-3.5-turbo ์ฌ์ฉ (GPT-4o ๋๋น ์ฝ 20๋ฐฐ ์ ๋ ด)๋ณต์กํ ๋ถ์์ด ํ์ํ ๊ฒฝ์ฐ๋ง
gpt-4o ์ฌ์ฉ์๋ฒ ๋ฉ์
text-embedding-3-small ์ฌ์ฉ (large ๋๋น 5๋ฐฐ ์ ๋ ด, ์ฑ๋ฅ ์ฐจ์ด ๋ฏธ๋ฏธ)
๋์ผํ๊ฑฐ๋ ๋งค์ฐ ์ ์ฌํ ํ ์คํธ๋ Redis ์บ์๋ก ์ฒ๋ฆฌ
์๋ฒ ๋ฉ ๊ฒฐ๊ณผ๋ ๋ฒกํฐ DB์ ์ ์ฅํด์ ์ฌ์ฌ์ฉ
OpenAI Prompt Caching ๊ธฐ๋ฅ ํ์ฉ (๋์ผ prefix ๋ฐ๋ณต ์ 50% ํ ์ธ)
System Prompt๋ ๊ฐ๊ฒฐํ๊ฒ ์ ์ง (๋ถํ์ํ ์ค๋ช ์ ๊ฑฐ)
์ ๋ ฅ ํ ์คํธ ์ ์ฒ๋ฆฌ๋ก ๋ถํ์ํ ๊ณต๋ฐฑ, ํน์๋ฌธ์ ์ ๊ฑฐ
max_tokens ํ๋ผ๋ฏธํฐ๋ก ์ถ๋ ฅ ๊ธธ์ด ์ ํ
์ค์๊ฐ ์ฒ๋ฆฌ๊ฐ ํ์ ์๋ ๊ฒฝ์ฐ Batch API ํ์ฉ (50% ํ ์ธ)
์ฌ๋ฌ ์ด์๋ฅผ ๋ชจ์์ ํ ๋ฒ์ ์ฒ๋ฆฌํ๋ ๋ฐฐ์น ํ์ดํ๋ผ์ธ ๊ตฌ์ฑ
- ์ด์๋น ํ๊ท ์ ๋ ฅ: ~500 tokens, ์ถ๋ ฅ: ~300 tokens
- ํ๋ฃจ ์ด ํ ํฐ: ์ ๋ ฅ 25,000 + ์ถ๋ ฅ 15,000
- ์ผ์ผ ๋น์ฉ: ($2.50 ร 0.025) + ($10.00 ร 0.015) = $0.0625 + $0.15 = ์ฝ $0.21/์ผ
- ์ ๋น์ฉ: ์ฝ $6.3 (์ฝ 8,500์)
GPT-3.5-turbo ์ฌ์ฉ ์ ์ ์ฝ $0.5 ์ดํ๋ก๋ ๊ฐ๋ฅ!
์ด๋ก ์ ๋ค ์๊ฒ ๊ณ ์ค์ ๋ก ํ์ ๋์ ํ ๋ ์ฃผ์ํด์ผ ํ ๊ฒ๋ค ์ ๋ฆฌํด์ค๊ฒ. ์ด๊ฑฐ ๋ชจ๋ฅด๊ณ ๋์ ํ๋ค๊ฐ ํ์๋คํํ ์ ๋จน๋ ๊ฒฝ์ฐ ์์ ใ ใ ใ
์์ ์๋ํ๋ณด๋ค๋ GPT๊ฐ ์ด์์ ๋ง๋ค๊ณ ๋ด๋น์๊ฐ ๊ฒํ ํ ์น์ธํ๋ ๋ฐ์๋ํ ๋ฐฉ์์ผ๋ก ์์ํ๋ ๊ฒ ์์ ํด. ์ ๋ขฐ๋๊ฐ ์์ด๋ฉด ์ ์ง์ ์ผ๋ก ์๋ํ ๋ฒ์๋ฅผ ๋ํ๊ฐ๋ ์ ๋ต ์ถ์ฒ.
๋ชจ๋ ์๋ ์์ฑ ์ด์์ "AI-generated" ๋ ์ด๋ธ์ ๋ถ์ด๊ณ , ์์ฑ ๋ก๊ทธ๋ฅผ ๋ณ๋๋ก ์ ์ฅํด. ๋์ค์ GPT๊ฐ ์๋ชป ๋ถ๋ฅํ ์ผ์ด์ค๋ฅผ ๋ถ์ํด์ ํ๋กฌํํธ๋ฅผ ๊ฐ์ ํ๋ ๋ฐ ํ์ฉํ ์ ์์ด.
์ฒ์์๋ ํ ํ๋ก์ ํธ, ํ ์ด์ ํ์ (์: ๋ฒ๊ทธ๋ง)์๋ง ์ ์ฉํด์ ํจ๊ณผ๋ฅผ ๊ฒ์ฆํ ํ ํ๋ํด. ํ ๋ฒ์ ์ ์ฒด ํ์ ์ ์ฉํ๋ฉด ํผ๋์ด ์๊ธธ ์ ์์ด.
System Prompt๋ฅผ ์ฝ๋์ฒ๋ผ Git์ผ๋ก ๋ฒ์ ๊ด๋ฆฌํด. ํ๋กฌํํธ ๋ณ๊ฒฝ์ด ์ด์ ํ์ง์ ํฐ ์ํฅ์ ๋ฏธ์น๊ธฐ ๋๋ฌธ์ ๋ณ๊ฒฝ ์ด๋ ฅ ์ถ์ ์ด ์ค์ํด.
OpenAI API์ Jira API ๋ชจ๋ Rate Limit์ด ์์ด. ์ง์ ๋ฐฑ์คํ(Exponential Backoff) ์ ๋ต์ผ๋ก ์ฌ์๋ ๋ก์ง์ ๊ตฌํํ๊ณ , ํ(Queue) ์์คํ (Redis Queue, Celery ๋ฑ)์ ํ์ฉํด์ ํธ๋ํฝ ์คํ์ดํฌ๋ฅผ ์ฒ๋ฆฌํด.
์ด๋ก ๋ง ์์ผ๋ฉด ์ฌ๋ฏธ์์งใ ใ ์ค์ ๋ก ์ด๋ฐ ์์คํ ์ ๋์ ํ ํ๋ค์ ์ฌ๋ก๋ฅผ ๋ณด๋ฉด์ ํ์ค์ ์ธ ๊ธฐ๋์น๋ฅผ ์ก์๋ณด์.
๋์ ํ: CS ์ฑ๋ ์ฌ๋ ๋ฉ์์ง โ ์๋์ผ๋ก Jira ์ด์ ์์ฑ โ ๋ด๋น์ ์๋ฆผ
๊ฒฐ๊ณผ: ์ด์ ์์ฑ ์๊ฐ 95% ์ ๊ฐ, ํ์ฅ์ด ์ค์ ๊ฐ๋ฐ์ ์ง์คํ ์ ์๊ฒ ๋จ
๊ตฌํ ๊ธฐ๊ฐ: ์ฝ 3์ผ (MVP ๊ธฐ์ค)
๋์ ํ: ํ์๋ก ํ ์คํธ โ GPT ๋ถ์ โ ์ก์ ์์ดํ ์๋ ์ถ์ถ โ Jira ํ์คํฌ ์์ฑ
๊ฒฐ๊ณผ: ์ก์ ์์ดํ ๋๋ฝ๋ฅ 80% ๊ฐ์, ํ์ ํ Jira ์ ๋ ฅ ์๊ฐ ์ ๋กํ
๊ตฌํ ๊ธฐ๊ฐ: ์ฝ 2์ฃผ (์์ ํ ํฌํจ)
๋์ ํ: Sentry Webhook โ ์๋ ๋ถ์ โ ์ค๋ณต ์ฒดํฌ โ Jira ์ด์ ์์ฑ โ ๋ด๋น์ ์๋ฆผ
๊ฒฐ๊ณผ: ์๋ฌ ๋์ ์๊ฐ ํ๊ท 45๋ถ โ 5๋ถ์ผ๋ก ๋จ์ถ, ์ค๋ณต ์ด์ 90% ๊ฐ์
๊ตฌํ ๊ธฐ๊ฐ: ์ฝ 1์ฃผ์ผ
์ง๊ธ๊น์ง ๋ฐฐ์ด ๊ฒ๋ค์ ๊ธฐ๋ฐ์ผ๋ก ๋ ๋ฐ์ ๋ ํํ์ธ AI ์์ด์ ํธ ๋ฐฉ์์ผ๋ก ํ์ฅํ ์ ์์ด. ๋จ์ ์๋ํ๋ฅผ ๋์ด์ AI๊ฐ ์ค์ค๋ก ํ๋จํ๊ณ ํ๋ํ๋ ์์ค์ด์ผ.
Function Calling์ ์ฌ์ฉํ๋ฉด GPT๊ฐ ์ง์ Jira API๋ฅผ ํธ์ถํ๋ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๋ ์์ด์ ํธ๋ฅผ ๋ง๋ค ์ ์์ด. ์ด๊ฒ ์ง์ง AI ์์ด์ ํธ์ ์์์ ์ด์ผ.
# Jira ๋๊ตฌ ์ ์ (Function Calling์ฉ)
tools = [
{
"type": "function",
"function": {
"name": "create_jira_issue",
"description": "Jira์ ์ ์ด์๋ฅผ ์์ฑํฉ๋๋ค",
"parameters": {
"type": "object",
"properties": {
"summary": {"type": "string", "description": "์ด์ ์ ๋ชฉ"},
"description": {"type": "string", "description": "์ด์ ์์ธ ์ค๋ช
"},
"issuetype": {"type": "string", "enum": ["Bug", "Task", "Story"]},
"priority": {"type": "string", "enum": ["Critical", "High", "Medium", "Low"]}
},
"required": ["summary", "issuetype", "priority"]
}
}
},
{
"type": "function",
"function": {
"name": "search_jira_issues",
"description": "Jira์์ ์ด์๋ฅผ ๊ฒ์ํฉ๋๋ค",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "๊ฒ์ ํค์๋"},
"status": {"type": "string", "description": "์ด์ ์ํ ํํฐ"}
},
"required": ["query"]
}
}
}
]
def run_jira_agent(user_message: str):
"""
Jira ๊ด๋ฆฌ AI ์์ด์ ํธ ์คํ
์ฌ์ฉ์์ ์์ฐ์ด ์์ฒญ์ ๋ฐ์ ์ ์ ํ Jira ์์
์ ์ํ
"""
messages = [
{"role": "system", "content": "๋น์ ์ Jira ์ด์ ๊ด๋ฆฌ ์ ๋ฌธ AI ์์ด์ ํธ์
๋๋ค. ์ฌ์ฉ์์ ์์ฒญ์ ๋ถ์ํ๊ณ ์ ์ ํ Jira ์์
์ ์ํํ์ธ์."},
{"role": "user", "content": user_message}
]
# ์์ด์ ํธ ๋ฃจํ
while True:
response = client.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
tool_choice="auto"
)
message = response.choices[0].message
# ๋๊ตฌ ํธ์ถ์ด ์์ผ๋ฉด ์ข
๋ฃ
if not message.tool_calls:
return message.content
# ๋๊ตฌ ํธ์ถ ์ฒ๋ฆฌ
messages.append(message)
for tool_call in message.tool_calls:
func_name = tool_call.function.name
func_args = json.loads(tool_call.function.arguments)
# ์ค์ ํจ์ ์คํ
if func_name == "create_jira_issue":
jira = JiraClient()
result = jira.create_issue(func_args)
func_result = f"์ด์ ์์ฑ ์๋ฃ: {result['key']}"
elif func_name == "search_jira_issues":
jira = JiraClient()
issues = jira.search_similar_issues(func_args["query"])
func_result = json.dumps([i["key"] + ": " + i["fields"]["summary"] for i in issues])
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": func_result
})
# ์ฌ์ฉ ์์
# result = run_jira_agent("๊ฒฐ์ ๊ด๋ จ ๋ฒ๊ทธ๊ฐ 3๊ฐ ์๋์ง ํ์ธํ๊ณ , ์์ผ๋ฉด ์๋ก ๋ง๋ค์ด์ค")
# โ GPT๊ฐ ๋จผ์ ๊ฒ์ํ๊ณ , ์์ผ๋ฉด ์๋์ผ๋ก ์ด์ ์์ฑํ๋ ๋ฉํฐ์คํ
์์ด์ ํธ ๋์!
JiraToolkit์ ํ์ฉํ๋ ๋ฐฉ๋ฒ๋ ์์ด. LangChain์๋ ์ด๋ฏธ Jira ์ฐ๋ ๋๊ตฌ๊ฐ ๋ด์ฅ๋์ด ์์ด์ ํจ์ฌ ๋น ๋ฅด๊ฒ ๊ตฌํ ๊ฐ๋ฅํด. ์ฌ๋ฅ๋ท์์ LangChain ์ ๋ฌธ๊ฐ๋ฅผ ์ฐพ์๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ!
1. ๊ธฐ๋ณธ ๊ตฌ์กฐ: ์์ฐ์ด ์ ๋ ฅ โ ChatGPT ๋ถ์ โ ๊ตฌ์กฐํ๋ JSON โ Jira REST API โ ์ด์ ์์ฑ
2. ํต์ฌ ๊ธฐ์ : OpenAI API (GPT-4o), Jira REST API v3, FastAPI ์นํ ์๋ฒ, Python
3. ์๋ํ ๊ฐ๋ฅ ๋ฒ์: ์ด์ ์์ฑ, ์ฐ์ ์์ ๋ถ๋ฅ, ๋ด๋น์ ๋ฐฐ์ , ์คํ๋ฆฐํธ ๋ฐฐ์ , ์ค๋ณต ๊ฐ์ง, ์ค๋ช ๋ณด์
4. ๋น์ฉ: ํ๋ฃจ 50๊ฐ ์ด์ ์ฒ๋ฆฌ ๊ธฐ์ค ์ ์ฝ 8,500์ (GPT-4o ๊ธฐ์ค)
5. ํจ๊ณผ: ์ด์ ๊ด๋ฆฌ ์๊ฐ 95% ์ ๊ฐ, ์๋ฌ ๋์ ์๊ฐ 90% ๋จ์ถ, ์ค๋ณต ์ด์ 90% ๊ฐ์
6. ์ฃผ์์ฌํญ: ๋ฏผ๊ฐ ์ ๋ณด ๋ง์คํน, Human-in-the-loop ์ค๊ณ, ์ ์ง์ ๋์ ์ ๋ต ํ์
์ด๋? ์๊ฐ๋ณด๋ค ์ง์
์ฅ๋ฒฝ์ด ๋์ง ์์ง? ใ
ใ
ใ
ChatGPT + Jira ์ฐ๋ ์๋ํ๋ ํ๋ฃจ ์ดํ์ด๋ฉด MVP๋ฅผ ๋ง๋ค ์ ์๋ ํ์ค์ ์ธ ์๋ํ์ผ. ๋ณต์กํ ML ๋ชจ๋ธ ํ์ต๋ ํ์ ์๊ณ , ๊ทธ๋ฅ API ๋ ๊ฐ ์ฐ๊ฒฐํ๋ฉด ๋๋ ๊ฑฐ๊ฑฐ๋ .
๊ฐ๋ฐ์๋ก์ ๊ฐ์ฅ ์ค์ํ ๊ฑด ๋ฐ๋ณต ์์
์ ์๊ฐ์ ๋ญ๋นํ์ง ์๋ ๊ฒ์ด์ผ. ์ด์ ๋ง๋ค๊ณ ๋ถ๋ฅํ๊ณ ๋ฐฐ์ ํ๋ ๋ฐ ํ๋ฃจ์ 1~2์๊ฐ์ฉ ์ฐ๋ ๊ฑด ์ง์ง ์๊น์์. ๊ทธ ์๊ฐ์ ์ฝ๋ ํ ์ค ๋ ์ง๊ณ , ์ํคํ
์ฒ ๋ ๊ณ ๋ฏผํ๊ณ , ํ์๋ค์ด๋ ๊ธฐ์ ํ ๋ก ํ๋ ๊ฒ ํจ์ฌ ๊ฐ์น ์์ด.
AI ์์ด์ ํธ ์๋์ ์ด๊ณ ์๋ ์ฐ๋ฆฌ๊ฐ AI๋ฅผ ๋๊ตฌ๋ก ์ ํ์ฉํ๋ ๊ฒ, ๊ทธ๊ฒ ์ง์ง ํ๋ ๊ฐ๋ฐ์์ ์ญ๋์ด์ผ. ์ค๋ ๋ฐฐ์ด ๋ด์ฉ์ผ๋ก ํ์ ์์ฐ์ฑ์ ํ ๋จ๊ณ ์ฌ๋ ค๋ณด์! ๐ช
์์์ ์๊ฒ, ์ํฉํธ๋ ํฌ๊ฒ! ํ์ดํ
๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.