Venue: NAACL 2025

# Schema and Natural Language Aware In-Context Learning for Improved GraphQL Query Generation

 Nitin Gupta

IBM Research, India

ngupta47@in.ibm.com &Manish Kesarwani

IBM Research, India

manishkesarwani@in.ibm.com &Sambit Ghosh

IBM Research, India

sambit.ghosh@ibm.com \\ Sameep Mehta

IBM Research, India

sameepmehta@in.ibm.com &Carlos Eberhardt

IBM StepZen

carloseeibm.com &Dan Debrunner

IBM StepZen

Dan.Debrunner@ibm.com \\ \end{tabular}

###### Abstract

GraphQL offers a flexible alternative to REST APIs, allowing precise data retrieval across multiple sources in a single query. However, generating complex GraphQL queries remains a significant challenge. Large Language Models (LLMs), while powerful, often produce suboptimal queries due to limited exposure to GraphQL schemas and their structural intricacies. Custom prompt engineering with incorrect examples is a common approach to guide LLMs, but existing methods, like randomly selecting examples, often yield unsatisfactory results. While semantic similarity-based selection is effective in other domains, it falls short for GraphQL, where understanding schema-specific nuances is crucial for accurate query formulation.

To address this, we propose a Schema and NL-Aware In-context Learning (SNAIL) framework that integrates both structural and semantic information from GraphQL schemas with natural language inputs, enabling schema-aware in-context learning. Unlike existing methods, our approach captures the complexities of GraphQL schemas to improve query generation accuracy. We validate this framework on a publicly available complex GraphQL test dataset, demonstrating notable performance improvements, with specific query classes showing up to a \(20\%\) performance improvement for certain LLMs. As GraphQL adoption grows, with Gartner predicting over \(60\%\) of enterprises will use it in production by \(2027\), this work addresses a critical need, paving the way for more efficient and reliable GraphQL query generation in enterprise applications.

## 1 Introduction

GraphQL is a powerful query language and runtime for APIs, offering a flexible alternative to REST by allowing clients to request precise data from interconnected sources in a single query. At its core, GraphQL relies on a schema that defines object types, their relationships, and supported operations (queries and mutations). While this schema-driven approach enhances flexibility and efficiency, its complexity in larger systems can make generating accurate queries challenging.

According to a Gartner report [3], by 2027, over 60% of enterprises are expected to use GraphQL in production, up from less than 30% in 2024. This rapid adoption underscores GraphQL's growing significance and the need for researchers and developers to address challenges in scalability, and usability. These advancements are essential for GraphQL to meet the evolving demands of modern enterprises.

Large language models (LLMs) can assist by generating GraphQL queries from natural language (NL) inputs, leveraging the schema to fulfill user requests. However, as noted in [9], the scarcity of publicly available GraphQL datasets limits LLM exposure to schema-specific patterns, reducing their effectiveness in producing valid queries. Incorporating in-context examples in prompts has been shown to improve performance, but selecting these examples effectively is critical. Existing methods for few-shot selection typically rely on semantic similarity between the input query and NL representations of the few-shot examples. However, in the context of GraphQL, the schema's structure and relationships play a pivotal role in query formulation. This raises a key research question: _Can the GraphQL schema be leveraged to refine few-shot selection and enhance contextual relevance?_ In this paper, we investigate this pivotal question and propose a novel framework that significantly enhances LLM performance for GraphQL query generation.

### Contribution

We propose a Schema and NL-Aware In-context Learning (SNAIL) framework (shown in Figure 1) to enhance LLM performance in GraphQL query

generation by refining in-context example selection. Unlike traditional semantic similarity-based methods, SNAIL dynamically selects examples by incorporating both structural and semantic similarities tailored to each NL query. Structural similarity is evaluated using two components: (1) subgraph isomorphism to align the input schema with schemas in the few-shot pool, capturing hierarchical and entity relationships, and (2) a category-based similarity metric that incorporates schema nesting and filter relationships, ensuring comprehensive schema representation.

We implemented both the semantic similarity method and the SNAIL framework for incontext example selection and evaluated GraphQL query generation performance across 9 open-source LLMs using the test set from the only available GraphQL benchmark Kesarwani et al. (2024). Experimental results show that SNAIL consistently improves accuracy over the semantic similarity approach across models and scenarios.

## 2 Related Work

GraphQL has gained significant attention in academia and industry for its flexibility and efficiency in managing data interactions. While studies have explored the advantages of GraphQL over REST APIs--such as reduced client-server interactions Brito et al. (2019), improved maintainability Brito and Valente (2020), and optimized data fetching Seabra et al. (2019); Mikula and Dzienkowski (2020)--technical challenges remain. For example, Belhadi et al. (2024) investigates testing methodologies for query validation, while Quina Mera et al. (2023) examines its capacity to represent complex data structures. GraphQL's role in real-world applications, including data integration across heterogeneous sources, is highlighted in Li et al. (2024).

Recent efforts to leverage large language models (LLMs) for GraphQL query generation include several notable approaches Levin (2023); gal (2023); a gor (2023). However, the introduction of a GraphQL-specific dataset in Kesarwani et al. (2024) marks the first attempt to systematically address training and evaluation for such tasks. Despite this, the study does not fully address the need for adaptive few-shot learning techniques that incorporate both semantic and structural schema characteristics.

Existing query generation systems typically rely on semantic similarity between natural language (NL) queries and examples, overlooking the critical role of schema structure. In summary, while prior research highlights GraphQL's strengths and challenges in API management, our work improves the GraphQL query generation performance of the state of the art LLMs by introducing an adaptive few-shot learning framework. This approach bridges gaps in existing methodologies, enabling LLMs to better handle the complexity and diversity of real-world GraphQL schemas.

## 3 Proposed SNAIL Framework

We propose the Schema and NL-Aware In-context Learning (SNAIL) framework (Figure 1) for gen

Figure 1: Proposed SNAIL Framework for GraphQL Generation.

 

erating GraphQL queries from Natural Language (NL) utterances. Unlike traditional methods relying on semantic similarity, our framework dynamically selects few-shot examples based on both structural and semantic similarities, tailored to each query.

As shown in Figure 1, the process starts by sampling and storing k few-shot examples (schemas, GraphQL queries, and corresponding utterances) from the dataset Kesarwani et al. (2024). Upon receiving test samples, the framework assesses structural similarity between the test schema and few-shot examples, while also evaluating semantic similarity with the test utterance. These similarity metrics rank and group the examples for in-context learning, which, along with instructions and the input query, is passed to large language models (LLMs) for final GraphQL query generation. By incorporating both structural and semantic similarities, SNAIL framework improves the precision and adaptability of query generation.

### Structural Similarity

We assess structural similarity through two components. First, we use subgraph isomorphism to compare the alignment between the query schema and the samples, capturing relationships like hier

Figure 3: Illustration of Schema Categories Extraction.

Figure 2: Illustration of Schema Structure Extraction.

 

archies and entity connections. Second, we define a category-based similarity metric to account for attributes such as the number of hops (depth of nested relationships) and filter conditions, which determine data inclusion. This approach allows us to consider both high-level schema properties and operational characteristics relevant to the query.

#### 3.1.1 Schema Structure Analysis

The Schema Structure Level focuses on assessing the structural similarity between the query sample schema and the schemas of the few-shot examples. This step is crucial for identifying samples that exhibit similar structural characteristics. To achieve this, we convert the schemas into graph representations, allowing us to analyze their structural properties more effectively.

Lets \(G\) denotes the query graph, and let \(S=[S_{1},S_{2},...,S_{n}]\) denotes the graphs corresponding to \(n\) few shot samples. The process involves finding the maximum size query schema subgraph i.e \(G^{\prime}\) that is isomorphic to the subgraphs of the few-shot examples as shown in Figure 2. This isomorphism check enables us to determine which few-shot samples share similar structural patterns with the query schema. We have designed specific similarity metric that quantify this relationship, facilitating a more refined selection of relevant few-shot examples based on their structural alignment with the query. By leveraging these metrics, we ensure that the selected samples are not only relevant in content but also in their underlying structural organization. Schema structure similarity, \(ST\) can be calculated as:

\[ST(G,S_{k})=\frac{|E(G^{\prime})|}{|E(G)|} \tag{1}\]

Where \(|E(G^{\prime})|\) and \(|E(G)|\) denote the number of edges in the isomorphic subgraph \(G^{\prime}\) and the query graph \(G\), respectively.

#### 3.1.2 Schema Categories Analysis

The Schema Category module predicts potential scenarios from the test schema, such as filter types (Figure 3 (b)) and multi-hop relationships (Figure 3 (a)). This categorization helps select few-shot examples that match the structural complexity of the schema being queried. By analyzing the test schema, we identify key attributes and select few-shot examples from the pool that align with these categories, ensuring consistency in schema complexity. Let \(Q(S)\) denote the query schema, and \(F(S)=F(S)_{1},F(S)_{2},\ldots,F(S)_{n}\) represent the \(n\) schema samples in the few-shot pool. The hop category similarity (\(HC\)) is:

\[HC(Q(S),F(S)_{k})=\frac{|\text{Overlap}(Q(S)^{h},F(S)_{k}^{h})|}{|Q(S)^{h}|}\]

Where, \(Q(S)^{h}\) and \(|F(S)_{k}^{h}\) denote the set of hops detected in \(Q(S)\) and \(F(S)_{k}\) respectively, and \(Overlap(Q(S)^{h},F(S)_{k}^{h})\) denotes the overlap between these two sets.

Similarly, the filter category similarity (\(FC\)) can be calculated as:

\[FC(Q(S),F(S)_{k})=\frac{|\text{Overlap}(Q(S)^{f},F(S)_{k}^{f})|}{|Q(S)^{f}|}\]

Where, \(Q(S)^{f}\) and \(F(S)_{k}^{f}\) denote the set of filters in \(Q(S)\) and \(F(S)_{k}\) respectively, and \(Overlap(Q(S)^{f},F(S)_{k}^{f})\) denotes the overlap between these two sets.

### Semantic Similarity

Semantic similarity (\(SS\)) is calculated using traditional similarity measures on embeddings, where NL queries are mapped to a high-dimensional vector space. A pre-trained LM generates these embeddings, capturing the contextual meaning and nuances of the query.

\[SS(Q(NL),F(NL)_{k})=CD(Emb(Q(NL)),\\ Emb(F(NL)_{k}))\]

Where, \(Emb(Q(NL))\) and \(Emb(F(NL)_{k})\) denote the embedding of test query \(Q(NL)\) and the \(k^{th}\) few-shot sample \(F_{k}\) respectively, and \(CD(,)\) denotes the cosine similarity between these two embedding vectors.

### Ranking Mechanism

To achieve effective sample selection, we propose a systematic approach utilizing three similarity metrics: schema structure, schema category, and semantic similarity. A circular selection strategy ranks samples by each metric, iteratively selecting the highest-ranked sample from schema structure, schema category, and semantic similarity in sequence. This process continues until the user-defined few-shot sample limit is met, ensuring balanced consideration of all metrics.

In cases of identical similarity scores, diversity is prioritized to ensure a comprehensive representation of structural patterns and semantic nuances.

 

This approach enhances the model's capacity for robust in-context learning, leading to improved accuracy in generating GraphQL queries from natural language inputs.

### Grouping and Selection based on LLM Context Length

Once the samples are selected, we regroup them to fit more few-shot examples into the context. For instance, if selected samples 1 and 2 share the same schema, we combine them into a single schema with multiple queries. This approach makes more efficient use of the available context space and ensures that the model has a richer set of examples to learn from.

## 4 Experiments

### Datasets

We use the GraphQL test set from Kesarwani et al. (2024), which consists of 986 test triplets (GraphQL Schema, NL Query, GraphQL Query) and consider test samples from seven categories: (a) Zero Hop, (b) One Hop, (c) Two Hop, (d) Zero Hop + Filter, (e) One Hop + Filter, (f) Two Hop + Filter, and (g) Filter. The distribution of these categories is presented in Table 1. For few-shot learning, we curated 23 few-shot samples that capture different complexities of data, ensuring no schema overlap between the test and few-shot samples.

### Models

We test our proposed system on \(9\) widely known LLMs: codellama-34b-instruct Roziere et al. (2023), deepseek-coder-33b-instruct Guo et al. (2024), ibm-granite-8b-code-instruct Mishra et al. (2024), llama-3-8b-instruct Facebook, Ilama-3-70b-instruct (Facebook), mixtral-8x7b-instructv01 Jiang et al. (2023), Ilama-3-1-70b-instruct (Facebook), qwen2-72b-instruct (qwe, 2024), and prometheus-8x7b-v2 Kim et al. (2024). GPT-4 was not included in the evaluation due to the cost associated with its API. Greedy decoding was employed to obtain outputs from the LLMs for reproducibility. The all-distilroberta-v1 BERT model was used to extract embeddings for the semantic similarity module. The number of few-shot examples was set to 5. We evaluated the accuracy of the generated GraphQL queries based on their correctness.

Footnote 1: [https://huggingface.co/sentence-transformers/all-distilroberta-v1](https://huggingface.co/sentence-transformers/all-distilroberta-v1)

### Baselines

We compared our approach against the following two baselines:

**Base Model without Few-shot:** This baseline uses only the instruction and test sample as input to the LLMs, without incorporating any few-shot examples.

**Semantic Few-shot:** This baseline uses semantic similarity to select few-shot examples. While no existing work in GraphQL explicitly applies this, we include it as a variation of our approach. Few-shot samples are retrieved based on semantic similarity for in-context learning.

### Results and Discussions

The results across various complexity sub-datasets are presented in Tables 2-8, with Table 9 summarizing the overall system performance. The proposed framework shows a 10-50% improvement over the base model without few-shot examples, indicating that base models lack sufficient GraphQL exposure during training. This suggests two research directions: (a) leveraging in-context learning to provide relevant information, or (b) fine-tuning on a GraphQL-specific dataset. Given the scarcity of GraphQL training data, in-context learning with dynamic sample selection, as implemented in the SNAIL framework, emerges as the more practical approach. We also compared our approach with the standard semantic-based few-shot selection, which had not been benchmarked previously. Our method improved performance by 3-5% on average by incorporating structural and categorical similarity.

Among the evaluated models, the llama-3-70b-instruct model consistently outperformed others, with a maximum margin of 21% and a minimum of 4%. Compared to the base model, it showed a 45% overall improvement. The mixtral-8x7b-instruct-v01 model outperformed smaller models (<8B parameters) by 2-8%. Some LLMs showed improvements exceeding 10% in specific dataset complexities, demonstrating the effectiveness of our framework over the semantic-based approach. In some cases, semantic similarity performed well, likely due to the limited size of our few-shot pool. Future work will expand the pool with more complex categories to further enhance performance.

## 5 Conclusion

We introduce a novel few-shot learning approach for generating GraphQL queries from natural lan 



\begin{table}
\begin{tabular}{|c|c|c|c|c|c|} \hline
**Models** & **Base Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 57.81 & 72.19 & **73.12** \\ \hline
**depgesek-core-33b-instruct** & 69.38 & 71.94 & **72.81** \\ \hline
**lbm-granite-8b-code-instruct** & 21.56 & **56.25** & 53.44 \\
**prometheus-8x7b-v2** & 23.75 & 54.69 & **66.56** \\ \hline
**llama-3-8b-instruct** & 2.5 & 53.75 & **57.81** \\ \hline
**lmaa-3-70b-instruct** & 29.38 & 76.25 & **77.81** \\ \hline
**mlratkar-8x7b-instruct+0i** & 32.5 & 61.25 & **68.44** \\ \hline
**qwen2-72b-instruct** & 47.81 & **75.94** & 71.25 \\ \hline
**liama-3-1-70b-instruct** & 63.75 & 70.31 & **74.69** \\ \hline \end{tabular} 
\begin{tabular}{|c|c|c|c|} \hline
**Models** & **Baseline Model** & **Semantic** & **SAIALL** \\  & **w/o Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 13.89 & 15.28 & **25.0** \\ \hline
**depgeseck-color-33b-instruct** & 12.50 & 20.81 & **41.67** \\
**lim-granite-8b-code-instruct** & 2.78 & 5.56 & **6.94** \\
**prometheus-8x7b-v2** & 6.94 & 16.67 & **29.17** \\ \hline
**llama-3-8b-instruct** & 1.39 & **20.83** & 18.06 \\
**lama-3-70b-instruct** & 26.39 & 54.17 & **58.33** \\
**mixtrak-8x7b-instruct+0i** & 6.94 & 18.06 & **31.94** \\ \hline
**dugen2-72b-instruct** & 4.17 & 20.83 & **27.78** \\ \hline
**ldama-3-1-70b-instruct** & 16.67 & **58.06** & 54.17 \\ \hline \end{tabular}
\end{table}
Table 6: Results for Filter with one-hop queries

\begin{table}
\begin{tabular}{|c|c|c|c|c|} \hline
**Models** & **Base Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 13.89 & 15.28 & **25.0** \\ \hline
**depgesecker-color-33b-instruct** & 12.50 & 20.81 & **41.67** \\
**hm-granite-8b-code-instruct** & 2.78 & 5.56 & **6.94** \\
**pronetheus-8x7b-v2** & 6.94 & 16.67 & **29.17** \\ \hline
**llama-3-8b-instruct** & 1.39 & **20.83** & 18.06 \\
**hama-3-70b-instruct** & 26.39 & 54.17 & **58.33** \\
**imxtrak-8x7b-instruct+0i** & 6.94 & 18.06 & **31.94** \\ \hline
**dyne2-72b-instruct** & 4.17 & 20.83 & **27.78** \\
**ilama-3-1-70b-instruct** & 16.67 & **58.06** & 54.17 \\ \hline \end{tabular} 
\begin{tabular}{|c|c|c|c|} \hline
**Models** & **Baseline Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 29.4 & 61.54 & **67.03** \\
**deepesek-order-33b-instruct** & 52.2 & 59.17 & **68.41** \\
**ibn-granite-8b-code-instruct** & 21.43 & **42.31** & 38.19 \\
**prophethes-8x7b-v2** & 39.84 & 50.0 & **61.54** \\
**liama-3-8b-instruct** & 7.97 & 54.95 & **56.32** \\
**liama-3-70b-instruct** & 46.98 & 75.0 & **78.57** \\ \hline
**mirxtrak-8x7b-instruct+0i** & 40.66 & 52.75 & **62.36** \\
**open2-72b-instruct** & 20.88 & 59.07 & **64.29** \\ \hline
**liama-3-1-70b-instruct** & 43.41 & **76.37** & **76.37** \\ \hline \end{tabular}
\end{table}
Table 7: Results for Filter with two-hop queries

\begin{table}
\begin{tabular}{|c|c|c|c|} \hline
**Models** & **Base Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 29.4 & 61.54 & **67.03** \\
**deepseek-oder-33b-instruct** & 52.2 & 59.17 & **68.41** \\
**ibn-granite-8b-code-instruct** & 21.43 & **42.31** & 38.19 \\
**proteintheus-8x7b-v2** & 39.84 & 50.0 & **61.54** \\
**liama-3-8b-instruct** & 7.97 & 54.95 & **56.32** \\
**liama-3-70b-instruct** & 46.98 & 75.0 & **78.57** \\
**mixtrak-8x7b-instruct+0i** & 40.66 & 52.75 & **62.36** \\
**qwen2-72b-instruct** & 20.88 & 59.07 & **64.29** \\
**liama-3-1-70b-instruct** & 43.41 & **76.37** & **76.37** \\ \hline \end{tabular}
\end{table}
Table 8: Results for Filter using

\begin{table}
\begin{tabular}{|c|c|c|c|} \hline
**Models** & **Base Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 29.4 & 61.54 & **67.03** \\
**deepseek-oder-33b-instruct** & 52.2 & 59.17 & **68.41** \\
**libn-granite-8b-code-instruct** & 21.43 & **42.31** & 38.19 \\
**pronetheus-8x7b-v2** & 39.84 & 50.0 & **61.54** \\
**liama-3-8b-instruct** & 7.97 & 54.95 & **56.32** \\
**liama-3-70b-instruct** & 46.98 & 75.0 & **78.57** \\
**mixtrak-8x7b-instruct+0i** & 40.66 & 52.75 & **62.36** \\
**qwen2-72b-instruct** & 20.88 & 59.07 & **64.29** \\
**liama-3-1-70b-instruct** & 43.41 & **76.37** & **76.37** \\ \hline \end{tabular} 
\begin{tabular}{|c|c|c|c|} \hline
**Models** & **Baseline Model** & **Semantic** & **SNAIL** \\  & **w/o Few-shot** & **Few-shot** & **Few-shot** \\ \hline
**codellama-34b-instruct** & 29.4 & 61.54 & **67.03** \\
**deepseek-oder-33b-instruct** & 52.2 & 59.17 & **68.41** \\
**ibn-granite-8b-code-instruct** & 21.43 & **42.31** & 38.19 \\
**pronetheus-8x7b-v2** & 39.84 & 50.0 & **61.54** \\
**liama-3-8b-instruct** & 7.97 & 54.95 & **56.32** \\
**liama-3-70b-instruct** & 46.98 & 75.0 & **78.57** \\
**mixtrak-8x7b-instruct+0i** & 40.66 & 52.75 & **62.36** \\
**qwen2-72b-instruct** & 20.88 & 59.07 & **64.29** \\
**liama-3-1-70b-instruct** & 43.41 & **76.37** & **76.37** \\ \hline \end{tabular}
\end{table}
Table 8: Results for Filter with two-hop queries

guage descriptions. Our method dynamically selects relevant samples based on multi-level similarity metrics: schema structure similarity (SS), category-level similarity (HC), and natural language similarity (NL). This dynamic selection ensures that the chosen examples align with the input query's structural and semantic nuances, enhancing model performance. Evaluation across 9 widely-used LLMs shows that our approach outperforms traditional methods for few-shot selection.

## References

* [1]M. Krizhevsky, A. Nisserman, S. Grossman, M. Raghavan, D. Ramanan, C. Lillicrape, J. Schmidhuber, T. Darrell, P. Dollar, E. Farhadi, B. Garnett, W. Hayser, Y. Bengio, F. Bergmann, G. Hinton, I. Guyonneau, Z. Huang, X. Jia, V. LeCun, O. Ronnelly, and J. Dean. Salakhutdinov (2014)A fast learning framework for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3786-3795. Cited by: SS1.
* [2]S. Kim, J. Shin, Y. Cho, J. Jang, S. Longpre, H. Lee, S. Yun, S. Shin, S. Kim, J. Thorne, and M. Seo (2024) Prometheus: inducing fine-grained evaluation capability in language models. External Links: Link Cited by: SS1.
* [3]Y. Levin (2023) A developer's journey to the ai and graphql galaxy. External Links: Link Cited by: SS1.
* [4]H. Li, O. Hartig, R. Armiento, and P. Lambrix (2024) Ontology-based graphql server generation for data access and data integration. Semantic Web15 (5), pp. 1639-1675. External Links: ISSN 0029-31X Cited by: SS1.
* [5]M. Mishra, M. Stallone, G. Zhang, Y. Shen, A. Prasad, A. M. Soria, M. Merler, P. Selvam, S. Surendran, S. Singh, M. Sethi, X. Pang, P. Li, K. Wu, S. Zawd, A. Coleman, M. White, M. Lewis, R. Pavuluri, Y. Koffman, B. Lublinsky, M. de Buyser, I. Abdelaziz, K. Basu, M. Agarwal, Y. Zhou, C. Johnson, A. Goyal, H. Patel, Y. Shah, P. Zefros, H. Ludwig, A. Munawat, M. Crouse, P. KanPanipathi, S. Salaria, B. Caloi, S. Wen, S. Seelam, B. Belgodere, C. Fonseca, A. Singhee, N. Desai, D. D. Cox, R. Puri, and R. Panda (2024) Granite code models: a family of open foundation models for code intelligence. External Links: Link Cited by: SS1.
* [6]J. Schulter, S. Schuster, and J. Leskovec (2019) The role of the web. In European Conference on Computer Vision, pp. 101-108. Cited by: SS1.
* [7]R. Szabo, A. Gupta, and A. Gupta (2020) An introduction to deep neural networks. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1-10. Cited by: SS1.
* the rise of code intelligence. External Links: Link Cited by: SS1.
* [9]L. Lin, J. Liu, and J. Sun (2020) Multi-level similarity metric for database analysis. arXiv preprint arXiv:2009.03238. Cited by: SS1.
* [10]T. Lin, J. Liu, and J. Sun (2020) Multi-level similarity metric for database analysis. In Proceedings of the 2020 ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1-10. Cited by: SS1.
* [11]P. Ma, J. Shi, and J. Sun (2020) Multi-level similarity metric for database analysis. In Proceedings of the 2020 ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1-10. Cited by: SS1.
* [12]B. Roziere, J. Gehring, F. Gloeckle, S. Sootla, I. Gat, X. Ellen Tan, Y. Adi, J. Liu, T. Remez, J. Rapin, A. Kozhevnikov, I. Evtimov, J. Bitton, M. Bhatt, C. Cantor Ferrer, A. Grattafiori, W. Xiong, A. Defossez, J. Copet, F. Azhar, H. Touvron, L. Martin, N. Usunier, T. Scialom, and G. Synnaeve (2023) Code llama: open foundation models for code. External Links: Link Cited by: SS1.
* [13]M. Segaba, M. Teijpe Nazario, and G. Pinto (2019) Rest or graphql? a performance comparative study. In Proceedings of the XIII Brazilian Symposium on Software Components, Architectures, and Reuse, pp. 123-132