LangChain4j와 Spring AI를
Neo4j에 통합하다

<!-- Langchain Springboot integration: Spring Boot 통합 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>0.36.0</version>
</dependency>

<!-- Open AI integration: OpenAI 통합 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>0.36.0</version>
</dependency>

<!-- Neo4j Vector Store integration: Neo4j 통합 -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-neo4j</artifactId>
    <version>0.35.0</version>
</dependency>

<!-- LLM embeddings API -->
<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-embeddings-all-minilm-l6-v2</artifactId>
    <version>0.35.0</version>
</dependency>

# Open AI LLM Integration for Generating Summary using Chat Model.
langchain4j.open-ai.chat-model.api-key=<OPEN_AI_KEY>
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true

# Open AI LLM Integration for Generating Embeddings
langchain4j.open-ai.embedding-model.api-key=<OPEN_AI_KEY>
langchain4j.open-ai.embedding-model.model-name=text-embedding-3-large

# Neo4j Integration — 벡터 데이터베이스가 아닌 기본 통합
neo4j.uri=bolt://localhost:7687
neo4j.user=neo4j
neo4j.password=test1234
neo4j.database=hmreco
config.batchSize=5

@ConfigurationProperties(prefix = "neo4j")
public class Neo4jConfiguration {
    private String uri;
    private String user ;
    private String password ;
    private String database ;
   /** Getter/Setters **/
}

// 1) @Service 어노테이션으로 서비스 클래스를 정의하고 Neo4jConfiguration을 주입한다
@Service
@Configuration
@EnableConfigurationProperties(Neo4jConfiguration.class)
public class Neo4jService {
    @Autowired
    private Neo4jConfiguration configuration ;
    private Driver driver ;

    // 2) Neo4j 데이터베이스 연결을 초기화하는 setup 메서드
    public synchronized void setup() {
        if( driver == null ) {
            driver = GraphDatabase.driver(
                    configuration.getUri(),
                    AuthTokens.basic(
                            configuration.getUser(),
                            configuration.getPassword()));
            driver.verifyConnectivity();
        }
    }

public List<EncodeRequest> getDataFromDB(String startSeason, String endSeason) {
    setup();
    String cypherTemplate = """
        --- Cypher query to get the transactions
    """;
    String cypher = String.format(cypherTemplate, startSeason, endSeason);
    SessionConfig config = SessionConfig.builder()
        .withDatabase(configuration.getDatabase())
        .build();
    try (Session session = driver.session(config)) {
        List<EncodeRequest> data = session.executeRead(tx -> {
            List<EncodeRequest> out = new ArrayList<>();
            var records = tx.run(cypher);
            while (records.hasNext()) {
                var record = records.next();
                String id = record.get("elementId").asString();
                String articles = record.get("articles").asString();
                out.add(new EncodeRequest(articles, id));
            }
            return out;
        });
        return data;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}

public void saveEmbeddings(List<Map<String, Object>> embeddings) {
    setup();
    String cypher = """
        UNWIND $data as row
        WITH row
        MATCH ()-[r]->()
        WHERE elementId(r) = row.id
        SET r.summary = row.summary
        WITH row, r
        CALL db.create.setRelationshipVectorProperty(r, 'embedding', row.embedding)
    """;
    SessionConfig config = SessionConfig.builder()
        .withDatabase(configuration.getDatabase())
        .build();
    try (Session session = driver.session(config)) {
        session.executeWriteWithoutResult(tx -> {
            tx.run(cypher, Map.of("data", embeddings));
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void saveArticleEmbeddings(List<Map<String, Object>> embeddings) {
    setup();
    String cypher = """
        UNWIND $data as row
        WITH row
        MATCH (a:Article)
        WHERE elementId(a) = row.id
        CALL db.create.setNodeVectorProperty(a, 'embedding', row.embedding)
    """;
    SessionConfig config = SessionConfig.builder()
        .withDatabase(configuration.getDatabase())
        .build();
    try (Session session = driver.session(config)) {
        session.executeWriteWithoutResult(tx -> {
            tx.run(cypher, Map.of("data", embeddings));
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@AiService
public interface ChatAssistant {
    @SystemMessage("""
             ---Role--
             You are an helpful assistant with expertise in fashion
             for a clothing company.

             ---Goal--
             Your goal is to generate a summary of the products purchased
             by the customers and descriptions of each of the products.
             Your summary should contain two sections -
             Section 1 - Overall summary outlining the fashion preferences
             of the customer based on the purchases. Limit the summary to
             3 sentences
             Section 2 - highlight 3-5 individual purchases.

             You should use the data provided in the section below as the
             primary context for generating the response.
             If you don't know the answer or if the input data tables do not
             contain sufficient information to provide an answer, just say so.
             Do not make anything up.

             Data Description:
             - Each Customer has an ID. Customer ID is a numeric value.
             - Each Customer has purchased more than one clothing articles
               (products). Products have descriptions.
             - The order of the purchases is very important. You should take
               into account the order when generating the summary.

             Response:
             ---
             # Overall Fashion Summary:

             \\n\\n

             # Individual Purchase Details:

             -
             Data:
             {text}
    """)
    String chat(String text);
}

@Service
public class OpenAIChatService {
    private ChatAssistant assistant ;
    public OpenAIChatService(ChatAssistant assistant) {
        this.assistant = assistant;
    }
    public String getSummaryText(String input) {
        String out = assistant.chat(input) ;
        return out ;
    }
}

@Service
public class OpenAIEmbeddingModelService {
    EmbeddingModel embeddingModel ;
    public OpenAIEmbeddingModelService(EmbeddingModel embeddingModel) {
        this.embeddingModel = embeddingModel;
    }
    Embedding generateEmbedding(String text) {
        Response<Embedding> response = embeddingModel.embed(text) ;
        return  response.content() ;
    }
}

@Configuration
@EnableConfigurationProperties(RunConfiguration.class)
@RestController
public class LangchainGraphAugmentController {
    // Autowired 지시어로 개별 서비스들을 주입한다
    @Autowired private OpenAIEmbeddingModelService embeddingModelService ;
    @Autowired private Neo4jService neo4jService ;
    @Autowired private OpenAIChatService chatService ;
    @Autowired private RunConfiguration configuration ;

    // 처리 중인 요청들을 담는 전역 변수
    private HashMap<String, IRequest> currentRequests = new HashMap<>() ;

    @GetMapping("/augment/{startSeason}/{endSeason}")
    public String processAugment(
            @PathVariable (value="startSeason") String startSeason,
            @PathVariable (value="endSeason") String endSeason
    ) {
        String uuid = UUID.randomUUID().toString() ;
        ProcessRequest request = new ProcessRequest(
                chatService, embeddingModelService, neo4jService,
                configuration, startSeason, endSeason) ;
        currentRequests.put(uuid, request) ;
        Thread t = new Thread(request) ;
        t.start();
        return uuid ;
    }

    @GetMapping("/augmentArticles")
    public String processAugmentArticles() {
        String uuid = UUID.randomUUID().toString() ;
        ProcessArticles request = new ProcessArticles(
                embeddingModelService, neo4jService, configuration) ;
        currentRequests.put(uuid, request) ;
        Thread t = new Thread(request) ;
        t.start();
        return uuid ;
    }

    @GetMapping("/augment/status/{requestId}")
    public String getStatus(
            @PathVariable (value="requestId") String requestId) {
        IRequest request = currentRequests.get(requestId) ;
        if( request != null ) {
            if( request.isComplete() ) {
                currentRequests.remove(requestId) ;
            }
            return request.getCurStatus() ;
        } else {
            return "Request Not Found." ;
        }
    }
}

public class ProcessRequest implements Runnable, IRequest {
    // chatService, embeddingModelService, neo4jService, configuration,
    // startSeson, endSeason, curStatus = "0 %", isComplete = false ... 생성자 생략

    @Override
    public void run() {
        try {
            // 2) Neo4j에서 고객 거래 데이터를 가져온다. 각 레코드는 계절 시작 관계의
            //    ID(컨텍스트)와, 구매 순서대로의 품목 설명을 담는다
            System.out.println("Retrieving Data from Graph");
            List<EncodeRequest> dbData = neo4jService.getDataFromDB(startSeson, endSeason);
            System.out.println("Retrieved Data from Graph");
            int i = 0;
            int processingSize = dbData.size();
            List<Map<String, Object>> embeddings = new ArrayList<>();
            for( EncodeRequest request: dbData ) {
                // 배치 크기에 도달하면 Neo4j에 저장한다
                if (i > 0 && i % configuration.getBatchSize() == 0) {
                    System.out.println("Saving Embeddings to Graph : " + i);
                    neo4jService.saveEmbeddings(embeddings);
                    embeddings.clear();
                    curStatus = ( ( i * 100.0 ) / processingSize ) + " %";
                }
                i++;
                Map<String, Object> embedMap = new HashMap<>();
                // 3) 그래프에서 가져온 거래 목록을 넘겨 LLM 채팅 서비스로 요약을 얻는다
                String id = request.getId();
                System.out.println("Retrieving Summary");
                String summary = chatService.getSummaryText(request.getText());
                System.out.println("Retrieving embedding");
                // 4) 요약에 대해 임베딩 서비스를 지렛대 삼아 임베딩을 만든다
                Embedding embedding = embeddingModelService.generateEmbedding(summary);
                // 5) 관계 컨텍스트 ID와 함께 요약·임베딩을 레코드에 담아 배치에 저장한다
                embedMap.put("id", id);
                embedMap.put("embedding", embedding.vector());
                embedMap.put("summary", summary);
                embeddings.add(embedMap);
            }
            // 6) 배치에 남은 데이터가 있으면 Neo4j에 저장한다
            if( embeddings.size() > 0 ) {
                System.out.println("Saving Embeddings to Graph");
                neo4jService.saveEmbeddings(embeddings);
                embeddings.clear();
            }
            curStatus = "100 %";
        }catch (Exception e) {
            e.printStackTrace();
        }
        isComplete = true;
    }
}