How I Built a Plant RAG Application with Couchbase Vector Search on iOS

마트에서 아름다운 식물을 보았지만 그것이 무엇인지, 어떻게 돌봐야 할지 모를 때 그런 기분이 드시나요? 지난 봄에 제게도 그런 일이 있었는데, 휴대폰으로 식물에 비추기만 하면 식물에 대한 모든 것을 즉시 알 수 있다면 어떨까 하는 생각이 들었습니다.

그래서 저는 사진으로 식물을 식별하고 AI 기반 관리 조언을 제공하는 iOS 앱인 PlantPal을 만들었습니다. 멋진 부분은? 모든 것이 카우치베이스 벡터 검색을 사용하여 기기 내에서 실행됩니다. 인터넷도 필요 없고, 사진을 서버로 전송할 필요도 없이, 순수하게 로컬에서 식물을 식별하는 마법만 있으면 됩니다.

내가 만든 것

PlantPal은 꽤나 기술적인 모험이었습니다. 기본적으로 카메라로 식물을 식별한 다음 관리 지침에 대해 채팅할 수 있는 RAG 애플리케이션입니다. 하지만 다른 식물 앱과 다른 점은 다음과 같습니다:

모든 것이 휴대폰에서 로컬로 실행됩니다. 카메라로 뱀 식물을 비추면 뱀 식물임을 즉시 알아챌 수 있습니다. "얼마나 자주 물을 주어야 하나요?"라고 물으면 클라우드에 단 한 바이트도 전송하지 않고도 해당 식물에 대한 구체적인 조언을 제공합니다.

그리고 전체 앱 용량을 800MB에서 14MB로 압축하는 데 성공했습니다. 이 재앙에 대해서는 나중에 자세히 설명하겠습니다.

데모 비디오

기술 스택(또는: 벡터 데이터베이스를 사랑하는 법을 배운 방법)

이를 구축하려면 꽤 많은 부품이 필요했습니다:

- iOS + Swift - 당연히 아이폰에서 사용하고 싶었기 때문에
- 카우치베이스 라이트 벡터 검색 - 이것은 지역 식물 식별의 판도를 바꿨습니다.
- 모바일클립 - 이미지를 숫자로 변환하는 Apple의 컴퓨터 비전 모델
- 핵심 ML - 모든 것을 로컬에서 실행하는 경우
- 기초 모델 – Apple의 온디바이스 AI 프레임워크 채팅 기능을 위해 클라우드 종속성 없이 개인 정보 보호 우선 LLM 기능을 제공합니다.

전체 철학은 "모든 것을 로컬로 유지." 클라우드 API도 없고, 식물 사진을 임의의 서버로 전송할 필요도 없으며, 개인정보 보호의 악몽도 없습니다. 여러분과 휴대폰, 그리고 아주 영리한 수학만 있으면 됩니다.

1부: 1부: 벡터 검색 - 생각만큼 무섭지 않습니다.

대부분의 플랜트 앱이 형편없는 이유

솔직히 말해서 대부분의 식물 식별 앱은 매우 실망스럽습니다. 사진을 찍고 서버에 업로드되는 동안 3~5초를 기다린 다음 정확할 수도, 정확하지 않을 수도 있는 결과를 얻게 됩니다. 게다가 기본적으로 관엽식물 사진을 모르는 사람에게 보내는 것이나 마찬가지입니다.

저는 카메라를 식물에 대면 식물이 무엇인지 바로 알 수 있는 것처럼 즉각적으로 작동하는 기능을 원했습니다. 기다릴 필요도 없고, 인터넷이 필요하지 않으며, 개인정보 보호에 대한 우려도 없습니다.

벡터 검색. 알아요, 알아요 - 매우 기술적이고 위협적으로 들립니다. 하지만 실제로는 머리를 감싸면 꽤나 우아한 솔루션입니다.

벡터 임베딩의 마법

놀라운 점은 모든 이미지를 숫자 목록으로 바꿀 수 있다는 것입니다. 픽셀 값이 아니라 이미지에 포함된 내용을 나타내는 실제 의미 있는 숫자로 말이죠.

Rose photo → [0.1, 0.8, 0.3, ...] (512 numbers)
Tulip photo → [0.9, 0.2, 0.1, ...] (512 numbers)

1 2	Rose 사진 → [0.1, 0.8, 0.3, ...] (512 숫자) 튤립 사진 → [0.9, 0.2, 0.1, ...] (512 숫자)

아름다운 점은 비슷한 식물이 비슷한 숫자로 끝나는 것입니다. 두 장의 장미 사진은 벡터가 매우 비슷하지만 장미와 선인장은 완전히 다릅니다.

이 인사이트를 얻자 해결책이 명확해졌습니다. 숫자를 비교하기만 하면 됩니다! 카우치베이스 벡터 검색은 유사한 벡터를 찾는 모든 무거운 작업을 효율적으로 처리합니다.

실제 구현은 놀라울 정도로 깔끔하게 이루어졌습니다:

func search(image: UIImage) -> [Record] {
    // Turn the camera photo into numbers
    let embeddings = AI.shared.embeddings(for: image, attention: .zoom(factors: [1, 2]))
    
    for embedding in embeddings {
        let plantSearchResults = self.searchPlants(vector: embedding)
        if !plantSearchResults.isEmpty {
            return plantSearchResults
        }
    }
    return []
}

func 검색(이미지: UIImage) -> [기록] {

// 카메라 사진을 숫자로 바꾸기

let 임베딩 = AI.공유.임베딩(에 대한: 이미지, 주의: .줌(요인: [1, 2]))

에 대한 임베딩 in 임베딩 {

let 식물 검색 결과 = self.검색식물(벡터: 임베딩)

만약 !식물 검색 결과.isEmpty {

반환 식물 검색 결과

}

반환 []

}

2부: 위대한 MobileCLIP 마이그레이션

비전 프레임워크만으로는 충분하지 않은 경우

여기서부터 흥미로운 점이 생겼습니다. 저는 Apple의 Vision 프레임워크로 시작했는데, iOS에 내장되어 있고 당연한 선택처럼 보였기 때문입니다. 47개의 식물 사진을 사용한 초기 테스트에서는 완벽하게 작동했습니다. 제 자신에 대해 꽤 기분이 좋았습니다.

그러다 야망이 생겼습니다. 15,000종 이상의 식물 종으로 데이터베이스를 구축할 수 있다면 어떨까요? 그때 모든 것이 무너졌습니다.

문제는 정확성이었습니다. 대규모 데이터 세트에서 Vision 임베딩을 테스트했을 때, 비슷해 보이는 식물들이 계속 서로 혼동되는 현상이 발생했습니다. 예를 들어, 앱이 스네이크 플랜트를 ZZ 플랜트라고 인식하여 물을 주는 조언을 제공하려고 할 때 좋지 않은 상황이 발생했습니다.

알고 보니 Vision 프레임워크 임베딩은 제 사용 사례에 적합하지 않았습니다. 비슷해 보이는 식물의 벡터가 너무 가까워서 앱이 식물을 확실하게 구분할 수 없었습니다.

모바일클립

몇 번의 검색 끝에 (그리고 많은 좌절감 끝에) MobileCLIP을 발견했습니다. 이미지 유사도 작업을 위해 특별히 고안된 이 앱은 그 차이가 확연했습니다. 갑자기 비슷한 식물을 훨씬 더 뚜렷하게 구분할 수 있었고 정확도가 훨씬 높아졌습니다.

임베딩 생성 파이프라인을 다시 작성해야 하는 등 마이그레이션 작업은 다소 번거로웠지만 그만한 가치가 있었습니다. 이제 정확도가 절벽에서 떨어지지 않고 수천 종의 식물로 자신 있게 확장할 수 있습니다.

3부: 800MB의 재앙(그리고 어떻게 해결했나요?)

앱이 대부분의 게임보다 커지는 경우

제가 800MB 사태에 대해 언급했던 것을 기억하시나요? 네, 그 얘기요...

첫 번째 버전은 정말 말도 안 되는 것이었습니다. 고해상도 이미지가 포함된 전체 식물 데이터베이스와 여러 MobileCLIP 모델(S0, S1, S2, BLT), 그리고 언젠가 필요하다고 생각한 모든 텍스트 모델을 제공했죠. 이 앱은 기본적으로 AAA급 모바일 게임 크기였습니다.

아무도 800MB 용량의 식물 식별 앱을 다운로드하지 않을 것입니다. 정말 그럴까요?

계산 전 혁신

그때 제가 "아하"라고 부르는 순간이 찾아왔습니다. 앱을 실행할 때마다 왜 매번 같은 47개의 식물에 대한 임베딩을 생성하고 있었을까요? 그건 그냥... 낭비였어요.

내가 (잘못) 하고 있던 일:

- 앱 번들: 플랜트 이미지(10MB) + 모든 모델(800MB) = 810MB
- 모든 앱 실행: 모든 참조 플랜트에 대한 임베딩 생성
- 결과: 느린 시작, 터무니없는 파일 크기

내가 해야 할 일

- 구축 시간: 식물 이미지에서 임베딩 한 번 생성
- 앱 번들: 사전 계산된 임베딩(500KB) + 모델 1개(14MB) = 14MB
- 런타임: 새 카메라 사진에 대해서만 임베딩을 생성합니다.
- 결과: 즉시 시작, 일반 크기 앱

다음은 미리 계산된 임베딩 로더입니다:

class BuildTimeEmbeddingLoader {
    private var preComputedEmbeddings: [String: PreComputedPlantEmbedding] = [:]
    
    func loadPreComputedEmbeddings() {
        guard let embeddingsURL = Bundle.main.url(forResource: "plant_embeddings", withExtension: "json"),
              let data = try? Data(contentsOf: embeddingsURL),
              let embeddings = try? JSONDecoder().decode([PreComputedPlantEmbedding].self, from: data) else {
            return
        }
        
        // Load 47 plants × 512 dimensions = ~500KB total
        for embedding in embeddings {
            preComputedEmbeddings[embedding.plantId] = embedding
        }
        
        print(" Loaded \(embeddings.count) plants!")
    }
}

클래스 빌드시간 임베딩 로더 {

비공개 var 사전 컴퓨터 임베딩: [문자열: 사전 계산된 플랜트 임베딩] = [:]

func 로드 미리 계산된 임베딩() {

guard let 임베딩URL = 번들.메인.URL(forResource: "plant_embedings", 확장 기능: "json"),

let 데이터 = 시도? 데이터(contentsOf: 임베딩URL),

let 임베딩 = 시도? JSONDecoder().디코딩([사전 계산된 플랜트 임베딩].self, 에서: 데이터) else {

반환

}

// 47개 플랜트 × 512개 차원 = 총 500KB 로드

에 대한 임베딩 in 임베딩 {

사전 컴퓨터 임베딩[임베딩.plantId] = 임베딩

}

인쇄(" 로드됨 \(임베딩.카운트) 식물!")

}

혜택:

- 즉시 앱 시작: 임베딩 생성 불필요
- 98% 더 작은 스토리지: 임베딩 대 이미지
- 배터리 수명 향상: 런타임 시 계산 감소

4부: Couchbase가 무거운 작업을 처리하도록 만들기

데이터베이스 설정(예상보다 쉬움)

솔직히 말씀드리자면 "벡터 데이터베이스"라는 말을 처음 들었을 때는 엄청나게 복잡할 것이라고 생각했습니다. 하지만 Couchbase Lite는 놀라울 정도로 간단했습니다:

// Enable vector search extension
try! CouchbaseLiteSwift.Extension.enableVectorSearch()

// Create local database
let database = try! CouchbaseLiteSwift.Database(name: "plantpal")
let collection = try! database.defaultCollection()

// Vector index for 512-dimensional plant embeddings (MobileCLIP S1 model output size)
// VectorIndexConfiguration defines index parameters: data expression, vector dimensions, clustering centroids, and distance metrics
var imageVectorIndex = VectorIndexConfiguration(expression: "image", dimensions: 512, centroids: 8)
imageVectorIndex.metric = .cosine
imageVectorIndex.isLazy = true

try! collection.createIndex(withName: "ImageVectorIndex", config: imageVectorIndex)

// Full-text search for plant names
let ftsIndex = FullTextIndexConfiguration(["name", "scientificName"])
try! collection.createIndex(withName: "PlantNameIndex", config: ftsIndex)

print(" Vector search database ready!")

// 벡터 검색 확장 사용

시도! 카우치베이스라이트스위프트.확장.활성화 벡터 검색()

// 로컬 데이터베이스 만들기

let 데이터베이스 = 시도! 카우치베이스라이트스위프트.데이터베이스(이름: "plantpal")

let 컬렉션 = 시도! 데이터베이스.기본 컬렉션()

// 512차원 플랜트 임베딩을 위한 벡터 인덱스(MobileCLIP S1 모델 출력 크기)

// VectorIndexConfiguration은 데이터 표현식, 벡터 차원, 클러스터링 구심점, 거리 메트릭과 같은 인덱스 매개변수를 정의합니다.

var 이미지벡터인덱스 = 벡터 인덱스 구성(표현식: "이미지", 치수: 512, 중심: 8)

이미지벡터인덱스.metric = .코사인

이미지벡터인덱스.isLazy = true

시도! 컬렉션.createIndex(withName: "이미지벡터인덱스", 구성: 이미지벡터인덱스)

// 식물 이름 전체 텍스트 검색

let ftsIndex = 풀텍스트 인덱스 구성(["name", "학명"])

시도! 컬렉션.createIndex(withName: "PlantNameIndex", 구성: ftsIndex)

인쇄(" 벡터 검색 데이터베이스 준비 완료!")

모든 것을 바꾼 SQL++

여기서 Couchbase의 진가가 빛을 발합니다. 복잡한 유사도 알고리즘을 작성하는 대신 특수 벡터 함수와 함께 SQL++를 사용할 수 있습니다. 너무 쉬워요:

private func searchPlants(vector: [Float]) -> [Record] {
    let sql = """
        SELECT type, name, scientificName, price, location,
               wateringSchedule, careInstructions, characteristics,
               APPROX_VECTOR_DISTANCE(image, $embedding) AS distance
        FROM _
        WHERE type = "plant"
          AND distance BETWEEN 0 AND 0.4
        ORDER BY distance, name
        LIMIT 1
    """
   
    let query = try collection.database.createQuery(sql)
    query.parameters = Parameters()
        .setArray(MutableArrayObject(data: vector), forName: "embedding")

    // Process results into Plant objects
    var records = [Record]()
    for result in try query.execute() {
        let plant = Plant(
            name: result["name"].string ?? "",
            scientificName: result["scientificName"].string,
            wateringSchedule: extractWateringSchedule(from: result),
            careInstructions: extractCareInstructions(from: result),
            characteristics: extractCharacteristics(from: result)
        )
        records.append(plant)
    }

    return records
}

비공개 func 검색식물(벡터: [Float]) -> [기록] {

let sql = """

SELECT 유형, 이름, 학명, 가격, 위치,

살수일정, 관리지침, 특성,

APPROX_VECTOR_DISTANCE(image, $embedding) AS 거리

FROM _

WHERE 유형 = "plant"

그리고 0과 0.4 사이의 거리

거리, 이름 기준으로 주문

제한 1

"""

let 쿼리 = 시도 컬렉션.데이터베이스.createQuery(sql)

쿼리.매개변수 = 매개변수()

.setArray(뮤터블어레이 오브젝트(데이터: 벡터), forName: "임베딩")

// 결과를 플랜트 개체로 처리

var 레코드 = [기록]()

에 대한 결과 in 시도 쿼리.실행() {

let plant = 플랜트(

이름: 결과["name"].문자열 ?? "",

학명: 결과["학명"].문자열,

급수 일정: 추출 워터링 스케줄(에서: 결과),

관리지침: 추출 케어 지침(에서: 결과),

특성: 추출 특성(에서: 결과)

)

레코드.추가(plant)

}

반환 레코드

}

그리고 약_벡터_거리 함수는 대상 벡터와 데이터베이스의 벡터 사이의 대략적인 거리를 계산하여 SQL++ 쿼리와 여러 거리 메트릭을 지원하는 효율적인 하이브리드 검색을 가능하게 합니다.

5부: AI에게 식물에 대해 가르치기

실제로 유용한 채팅 만들기

좋아요, 식물을 식별할 수 있어요. 멋지네요. 하지만 그 다음에는요? 저는 사용자가 "물을 얼마나 자주 주어야 하나요?"와 같은 질문을 하고 일반적인 식물 관리 조언이 아닌 실제로 도움이 되는 답변을 얻을 수 있기를 바랐습니다.

바로 이 부분에서 RAG(검색 증강 세대)가 등장합니다. 기본적으로 방금 식별한 식물에 대한 구체적인 컨텍스트를 AI에 제공해야 했습니다. 제가 모든 식물 지식을 구조화한 방법은 다음과 같습니다:

class Plant: Record {
    let name: String?
    let scientificName: String?
    let wateringSchedule: WateringSchedule?
    let careInstructions: CareInstructions?
    let characteristics: PlantCharacteristics?
    
    struct WateringSchedule {
        let frequency: String
        let amount: String
        let notes: String
    }

    struct CareInstructions {
        let light: String
        let temperature: String
        let humidity: String
        let fertilizer: String
        let pruning: String
    }
    
    struct PlantCharacteristics {
        let toxicToPets: Bool
        let airPurifying: Bool
        let flowering: Bool
        let difficulty: String
    }
}

클래스 플랜트: 기록 {

let 이름: 문자열?

let 학명: 문자열?

let 급수 일정: 급수 일정?

let 관리지침: 관리 지침?

let 특성: 식물 특성?

구조체 급수 일정 {

let 빈도: 문자열

let 금액: 문자열

let 참고: 문자열

}

구조체 관리 지침 {

let 빛: 문자열

let 온도: 문자열

let 습도: 문자열

let 비료: 문자열

let 가지 치기: 문자열

}

구조체 식물 특성 {

let 독성 반려동물: Bool

let 공기 정화: Bool

let 개화: Bool

let 난이도: 문자열

}

식물이 식별되면 로컬 데이터에서 AI를 위한 풍부한 컨텍스트를 구축합니다:

private func buildPlantContext(for plant: Plant) -> String {
    let context = """
    You are PlantPal, an expert plant care assistant. You can ONLY answer questions about: \(plant.name ?? "Unknown Plant").

    PLANT INFORMATION:
    Name: \(plant.name ?? "Unknown")
    Scientific Name: \(plant.scientificName ?? "Not available")

    WATERING SCHEDULE:
    \(plant.wateringSchedule?.frequency ?? "Not specified")
    \(plant.wateringSchedule?.notes ?? "")

    CARE INSTRUCTIONS:
    Light: \(plant.careInstructions?.light ?? "Not specified")
    Temperature: \(plant.careInstructions?.temperature ?? "Not specified")
    Humidity: \(plant.careInstructions?.humidity ?? "Not specified")

    CHARACTERISTICS:
    Pet Safe: \(plant.characteristics?.toxicToPets == false ? "Yes" : "No")
    Air Purifying: \(plant.characteristics?.airPurifying == true ? "Yes" : "No")
    Difficulty: \(plant.characteristics?.difficulty ?? "Not specified")
    """

    return context
}

비공개 func 빌드플랜트컨텍스트(에 대한 plant: 플랜트) -> 문자열 {

let 컨텍스트 = """

귀하는 식물 관리 전문 도우미인 PlantPal입니다. 다음에 대한 질문에만 답변할 수 있습니다: \(plant.이름 ?? "알 수 없는 식물").

식물 정보:

이름: \(plant.이름 ?? "알 수 없음")

학명: \(plant.학명 ?? "사용할 수 없음")

급수 일정:

\(plant.급수 일정?.빈도 ?? "지정되지 않음")

\(plant.급수 일정?.참고 ?? "")

관리 지침:

빛: \(plant.관리지침?.빛 ?? "지정되지 않음")

온도: \(plant.관리지침?.온도 ?? "지정되지 않음")

습도: \(plant.관리지침?.습도 ?? "지정되지 않음")

특성:

애완동물 안전: \(plant.특성?.독성 반려동물 == false ? "예" : "아니요")

공기 정화: \(plant.특성?.공기 정화 == true ? "예" : "아니요")

난이도: \(plant.특성?.난이도 ?? "지정되지 않음")

"""

반환 컨텍스트

}

이를 통해 식별된 식물의 특정 관리 정보를 사용하여 상황에 맞는 풍부한 AI 응답을 제공합니다.

기초 모델 통합

채팅 기능은 다음을 활용합니다. Apple의 파운데이션 모델 를 사용하여 온디바이스 자연어 처리를 통해 모든 대화를 비공개로 유지하면서 상황 인식 응답을 통해 지능형 플랜트 관리 지침을 제공합니다.

6부: 성능 최적화

사이즈 감소 여정

- 시작: 모바일클립 8개 모델(800MB)
- 최적화되었습니다: MobileCLIP-S1 모델 1개(120MB)
- 결과: 85% 크기 감소와 정확도 향상!

7부: 내가 배운 것(어려운 방법)

실제로 효과가 있었던 것들

- 사전 계산된 임베딩 - 이것이 가장 큰 성과였습니다. 시작할 때마다 임베딩을 생성하던 방식에서 사전 계산을 통해 시작 시간과 앱 용량을 모두 절약할 수 있었습니다.
- 모바일클립 - 유사한 식물을 구별하는 데 있어 Vision 프레임워크보다 훨씬 뛰어납니다. 마이그레이션의 골칫거리를 감수할 가치가 충분합니다.
- 카우치베이스 벡터 검색 - 벡터 연산을 위한 SQL이 있다는 것은 획기적인 변화입니다. 더 이상 사용자 지정 유사성 알고리즘을 작성할 필요가 없습니다.
- 모든 것을 로컬로 유지 - 사용자는 인터넷 연결이나 개인 정보 보호에 대해 걱정할 필요가 없다는 점을 좋아합니다.

원활하게 진행되지 않은 사항

- 모델 크기 최적화 - 정확도와 파일 크기 사이의 적절한 균형을 찾기 위해 너무 많은 반복을 거쳤습니다. 8개의 서로 다른 모델을 배송하는 것은... 현명하지 못했습니다.
- 유사성 임계값 - 제대로 조정하는 데 시간이 오래 걸렸어요. 너무 엄격하면 아무것도 일치하지 않고, 너무 느슨하면 모든 것이 일치합니다.
- 자동화 구축 - 빌드 중에 실행되도록 임베딩 생성 파이프라인을 설정하는 것은 예상보다 까다로웠습니다.

다시 시작한다면

- 첫날부터 앱 크기를 고려하세요 - 800MB 앱을 출시하지 않으면 사람들이 다운로드하지 않습니다.
- 대규모 임베딩 모델 테스트 - 50개 공장에서는 효과가 있는 것이 5000개 공장에서는 효과가 없을 수 있습니다.
- 카우치베이스 벡터 검색은 당신의 친구입니다. - 벡터 유사도 매칭을 재창조하지 마세요.
- 빌드 시간 최적화 > 런타임 최적화 - 사용자가 기다리는 시간이 아닌 빌드 중에 무거운 작업을 수행하세요.
- 실제 데이터는 모든 것을 보여줍니다 - 알고리즘이 선별된 테스트 이미지에서는 완벽하게 작동하지만 실제 사용자 사진에서는 완전히 실패할 수 있습니다.

다음 단계는 무엇인가요?

- 더 많은 식물 종으로 확장
- 식물 관리 알림 및 진행 상황 추적 추가
- 식물 공유를 위한 커뮤니티 기능

마무리

PlantPal을 구축하는 과정은 예상보다 훨씬 더 교육적이었습니다. "식물 식별이 얼마나 어려울까?"라는 생각으로 시작했는데 벡터 데이터베이스, 임베딩 모델, 모바일 최적화 기술에 대한 깊은 이해를 얻게 되었습니다.

가장 멋진 부분은? 이제 휴대폰으로 말 그대로 어떤 식물을 가리키면 그 식물이 무엇인지, 어떻게 관리해야 하는지 즉시 알 수 있습니다. 인터넷도 필요 없고, 개인정보 보호에 대한 걱정도 없고, 그저 현지의 마법과도 같습니다.

제가 가장 자랑스러워하는 것:

- 800MB의 괴물에서 세련된 14MB 앱으로 전환
- 스마트한 사전 계산을 통한 즉각적인 응답 달성
- 실제 세계에서 실제로 안정적으로 작동하는 무언가를 구축하세요.
- 복잡한 AI에 클라우드 서버가 필요하지 않다는 것을 입증한 사례

벡터 검색은 단순함과 강력함의 완벽한 중간 지점에 있는 것으로 밝혀졌습니다. 벡터 연산에 SQL을 사용할 수 있다는 것은 거의 속임수를 쓰는 것처럼 느껴질 정도로 Couchbase는 모든 작업을 생각보다 훨씬 쉽게 만들어 주었습니다.

비슷한 것을 만들 생각이라면 작게 시작해서 반복해 보세요. 제 첫 번째 버전은 형편없었지만 반복할 때마다 새로운 것을 배웠습니다. 그리고 첫 번째 시도에서 800MB 앱을 출시하지 마세요. 제 말을 믿으세요.

벡터 검색으로 무언가를 구축한 적이 있나요? 여러분의 이야기를 듣고 싶습니다! 나만의 식물 식별 앱을 만들어 보신다면 저에게 연락주세요. 다른 사람들이 어떤 앱을 만들어내는지 항상 궁금합니다.

리소스:

풀킷 미드하 - 개발자 에반젤리스트

이 문서 공유하기

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

iOS에서 카우치베이스 벡터 검색으로 Plant RAG 애플리케이션을 구축한 방법